migrate many `for` loops to `foreach`

29 files changed, 151 insertions, 152 deletions

diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs
index bf0dee0822f..e086334eb48 100644
--- a/src/libsyntax/abi.rs
+++ b/src/libsyntax/abi.rs
@@ -209,9 +209,9 @@ impl AbiSet {
         let mut abis = ~[];
         for self.each |abi| { abis.push(abi); }
 
-        for abis.iter().enumerate().advance |(i, abi)| {
+        foreach (i, abi) in abis.iter().enumerate() {
             let data = abi.data();
-            for abis.slice(0, i).iter().advance |other_abi| {
+            foreach other_abi in abis.slice(0, i).iter() {
                 let other_data = other_abi.data();
                 debug!("abis=(%?,%?) datas=(%?,%?)",
                        abi, data.abi_arch,
@@ -372,7 +372,7 @@ fn abi_to_str_rust() {
 
 #[test]
 fn indices_are_correct() {
-    for AbiDatas.iter().enumerate().advance |(i, abi_data)| {
+    foreach (i, abi_data) in AbiDatas.iter().enumerate() {
         assert!(i == abi_data.abi.index());
     }
 
@@ -387,7 +387,7 @@ fn indices_are_correct() {
 #[cfg(test)]
 fn check_arch(abis: &[Abi], arch: Architecture, expect: Option<Abi>) {
     let mut set = AbiSet::empty();
-    for abis.iter().advance |&abi| {
+    foreach &abi in abis.iter() {
         set.add(abi);
     }
     let r = set.for_arch(arch);
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 7e70817a68e..bee0f113aa7 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -163,7 +163,7 @@ pub fn map_fn(
     (cx,v): (@mut Ctx,
              visit::vt<@mut Ctx>)
 ) {
-    for decl.inputs.iter().advance |a| {
+    foreach a in decl.inputs.iter() {
         cx.map.insert(a.id, node_arg);
     }
     visit::visit_fn(fk, decl, body, sp, id, (cx, v));
@@ -201,12 +201,12 @@ pub fn map_item(i: @item, (cx, v): (@mut Ctx, visit::vt<@mut Ctx>)) {
     match i.node {
         item_impl(_, _, _, ref ms) => {
             let impl_did = ast_util::local_def(i.id);
-            for ms.iter().advance |m| {
+            foreach m in ms.iter() {
                 map_method(impl_did, extend(cx, i.ident), *m, false, cx);
             }
         }
         item_enum(ref enum_definition, _) => {
-            for (*enum_definition).variants.iter().advance |v| {
+            foreach v in (*enum_definition).variants.iter() {
                 cx.map.insert(v.node.id, node_variant(
                     /* FIXME (#2543) */ (*v).clone(),
                     i,
@@ -214,7 +214,7 @@ pub fn map_item(i: @item, (cx, v): (@mut Ctx, visit::vt<@mut Ctx>)) {
             }
         }
         item_foreign_mod(ref nm) => {
-            for nm.items.iter().advance |nitem| {
+            foreach nitem in nm.items.iter() {
                 // Compute the visibility for this native item.
                 let visibility = match nitem.vis {
                     public => public,
@@ -248,10 +248,10 @@ pub fn map_item(i: @item, (cx, v): (@mut Ctx, visit::vt<@mut Ctx>)) {
             );
         }
         item_trait(_, ref traits, ref methods) => {
-            for traits.iter().advance |p| {
+            foreach p in traits.iter() {
                 cx.map.insert(p.ref_id, node_item(i, item_path));
             }
-            for methods.iter().advance |tm| {
+            foreach tm in methods.iter() {
                 let id = ast_util::trait_method_to_ty_method(tm).id;
                 let d_id = ast_util::local_def(i.id);
                 cx.map.insert(
@@ -301,7 +301,7 @@ pub fn map_expr(ex: @expr, (cx,v): (@mut Ctx, visit::vt<@mut Ctx>)) {
     // Expressions which are or might be calls:
     {
         let r = ex.get_callee_id();
-        for r.iter().advance |callee_id| {
+        foreach callee_id in r.iter() {
             cx.map.insert(*callee_id, node_callee_scope(ex));
         }
     }
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 5ad325fed56..b8a2ea1b57d 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -278,7 +278,7 @@ pub fn split_trait_methods(trait_methods: &[trait_method])
     -> (~[TypeMethod], ~[@method]) {
     let mut reqd = ~[];
     let mut provd = ~[];
-    for trait_methods.iter().advance |trt_method| {
+    foreach trt_method in trait_methods.iter() {
         match *trt_method {
           required(ref tm) => reqd.push((*tm).clone()),
           provided(m) => provd.push(m)
@@ -391,10 +391,10 @@ impl id_range {
 
 pub fn id_visitor<T: Clone>(vfn: @fn(NodeId, T)) -> visit::vt<T> {
     let visit_generics: @fn(&Generics, T) = |generics, t| {
-        for generics.ty_params.iter().advance |p| {
+        foreach p in generics.ty_params.iter() {
             vfn(p.id, t.clone());
         }
-        for generics.lifetimes.iter().advance |p| {
+        foreach p in generics.lifetimes.iter() {
             vfn(p.id, t.clone());
         }
     };
@@ -408,13 +408,13 @@ pub fn id_visitor<T: Clone>(vfn: @fn(NodeId, T)) -> visit::vt<T> {
             match vi.node {
               view_item_extern_mod(_, _, id) => vfn(id, t.clone()),
               view_item_use(ref vps) => {
-                  for vps.iter().advance |vp| {
+                  foreach vp in vps.iter() {
                       match vp.node {
                           view_path_simple(_, _, id) => vfn(id, t.clone()),
                           view_path_glob(_, id) => vfn(id, t.clone()),
                           view_path_list(_, ref paths, id) => {
                               vfn(id, t.clone());
-                              for paths.iter().advance |p| {
+                              foreach p in paths.iter() {
                                   vfn(p.node.id, t.clone());
                               }
                           }
@@ -434,7 +434,7 @@ pub fn id_visitor<T: Clone>(vfn: @fn(NodeId, T)) -> visit::vt<T> {
             vfn(i.id, t.clone());
             match i.node {
               item_enum(ref enum_definition, _) =>
-                for (*enum_definition).variants.iter().advance |v| {
+                foreach v in (*enum_definition).variants.iter() {
                     vfn(v.node.id, t.clone());
                 },
               _ => ()
@@ -462,7 +462,7 @@ pub fn id_visitor<T: Clone>(vfn: @fn(NodeId, T)) -> visit::vt<T> {
         visit_expr: |e, (t, vt)| {
             {
                 let r = e.get_callee_id();
-                for r.iter().advance |callee_id| {
+                foreach callee_id in r.iter() {
                     vfn(*callee_id, t.clone());
                 }
             }
@@ -500,7 +500,7 @@ pub fn id_visitor<T: Clone>(vfn: @fn(NodeId, T)) -> visit::vt<T> {
                 }
             }
 
-            for d.inputs.iter().advance |arg| {
+            foreach arg in d.inputs.iter() {
                 vfn(arg.id, t.clone())
             }
             visit::visit_fn(fk, d, a, b, id, (t.clone(), vt));
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index 3c560d211fd..615b47e5681 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -228,7 +228,7 @@ pub fn sort_meta_items(items: &[@MetaItem]) -> ~[@MetaItem] {
  */
 pub fn find_linkage_metas(attrs: &[Attribute]) -> ~[@MetaItem] {
     let mut result = ~[];
-    for attrs.iter().filter(|at| "link" == at.name()).advance |attr| {
+    foreach attr in attrs.iter().filter(|at| "link" == at.name()) {
         match attr.meta().node {
             MetaList(_, ref items) => result.push_all(*items),
             _ => ()
@@ -316,7 +316,7 @@ pub fn test_cfg<AM: AttrMetaMethods, It: Iterator<AM>>
 pub fn require_unique_names(diagnostic: @span_handler,
                             metas: &[@MetaItem]) {
     let mut set = HashSet::new();
-    for metas.iter().advance |meta| {
+    foreach meta in metas.iter() {
         let name = meta.name();
 
         // FIXME: How do I silence the warnings? --pcw (#2619)
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index a9499881cff..d89057890f1 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -379,7 +379,7 @@ impl CodeMap {
     }
 
     pub fn get_filemap(&self, filename: &str) -> @FileMap {
-        for self.files.iter().advance |fm| { if filename == fm.name { return *fm; } }
+        foreach fm in self.files.iter() { if filename == fm.name { return *fm; } }
         //XXjdm the following triggers a mismatched type bug
         //      (or expected function, found _|_)
         fail!(); // ("asking for " + filename + " which we don't know about");
@@ -465,7 +465,7 @@ impl CodeMap {
         // The number of extra bytes due to multibyte chars in the FileMap
         let mut total_extra_bytes = 0;
 
-        for map.multibyte_chars.iter().advance |mbc| {
+        foreach mbc in map.multibyte_chars.iter() {
             debug!("codemap: %?-byte char at %?", mbc.bytes, mbc.pos);
             if mbc.pos < bpos {
                 total_extra_bytes += mbc.bytes;
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index 8be55ac0dc7..4c7c9c0c325 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -268,7 +268,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
         elided = true;
     }
     // Print the offending lines
-    for display_lines.iter().advance |line| {
+    foreach line in display_lines.iter() {
         io::stderr().write_str(fmt!("%s:%u ", fm.name, *line + 1u));
         let s = fm.get_line(*line as int) + "\n";
         io::stderr().write_str(s);
@@ -332,7 +332,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
 }
 
 fn print_macro_backtrace(cm: @codemap::CodeMap, sp: span) {
-    for sp.expn_info.iter().advance |ei| {
+    foreach ei in sp.expn_info.iter() {
         let ss = ei.callee.span.map_default(~"", |span| cm.span_to_str(*span));
         print_diagnostic(ss, note,
                          fmt!("in expansion of %s!", ei.callee.name));
diff --git a/src/libsyntax/ext/bytes.rs b/src/libsyntax/ext/bytes.rs
index e1face8a9b3..9b2b37fe402 100644
--- a/src/libsyntax/ext/bytes.rs
+++ b/src/libsyntax/ext/bytes.rs
@@ -21,13 +21,13 @@ pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree]) -> bas
     let exprs = get_exprs_from_tts(cx, sp, tts);
     let mut bytes = ~[];
 
-    for exprs.iter().advance |expr| {
+    foreach expr in exprs.iter() {
         match expr.node {
             // expression is a literal
             ast::expr_lit(lit) => match lit.node {
                 // string literal, push each byte to vector expression
                 ast::lit_str(s) => {
-                    for s.byte_iter().advance |byte| {
+                    foreach byte in s.byte_iter() {
                         bytes.push(cx.expr_u8(sp, byte));
                     }
                 }
diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs
index 900668df117..e47e3078636 100644
--- a/src/libsyntax/ext/concat_idents.rs
+++ b/src/libsyntax/ext/concat_idents.rs
@@ -18,7 +18,7 @@ use parse::token::{str_to_ident};
 pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> base::MacResult {
     let mut res_str = ~"";
-    for tts.iter().enumerate().advance |(i, e)| {
+    foreach (i, e) in tts.iter().enumerate() {
         if i & 1 == 1 {
             match *e {
                 ast::tt_tok(_, token::COMMA) => (),
diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs
index bde0a345b10..30dd89b02f1 100644
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@@ -110,7 +110,7 @@ fn decodable_substructure(cx: @ExtCtxt, span: span,
             let mut variants = ~[];
             let rvariant_arg = cx.ident_of("read_enum_variant_arg");
 
-            for fields.iter().enumerate().advance |(i, f)| {
+            foreach (i, f) in fields.iter().enumerate() {
                 let (name, parts) = match *f { (i, ref p) => (i, p) };
                 variants.push(cx.expr_str(span, cx.str_of(name)));
 
diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs
index 1f969b4e078..eb425ec029a 100644
--- a/src/libsyntax/ext/deriving/encodable.rs
+++ b/src/libsyntax/ext/deriving/encodable.rs
@@ -122,7 +122,7 @@ fn encodable_substructure(cx: @ExtCtxt, span: span,
         Struct(ref fields) => {
             let emit_struct_field = cx.ident_of("emit_struct_field");
             let mut stmts = ~[];
-            for fields.iter().enumerate().advance |(i, f)| {
+            foreach (i, f) in fields.iter().enumerate() {
                 let (name, val) = match *f {
                     (Some(id), e, _) => (cx.str_of(id), e),
                     (None, e, _) => (fmt!("_field%u", i).to_managed(), e)
@@ -153,7 +153,7 @@ fn encodable_substructure(cx: @ExtCtxt, span: span,
             let encoder = cx.expr_ident(span, blkarg);
             let emit_variant_arg = cx.ident_of("emit_enum_variant_arg");
             let mut stmts = ~[];
-            for fields.iter().enumerate().advance |(i, f)| {
+            foreach (i, f) in fields.iter().enumerate() {
                 let val = match *f { (_, e, _) => e };
                 let enc = cx.expr_method_call(span, val, encode, ~[blkencoder]);
                 let lambda = cx.lambda_expr_1(span, enc, blkarg);
diff --git a/src/libsyntax/ext/deriving/generic.rs b/src/libsyntax/ext/deriving/generic.rs
index 04bbe5ae1d6..cb74f152c1e 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -284,7 +284,7 @@ impl<'self> TraitDef<'self> {
                   _mitem: @ast::MetaItem,
                   in_items: ~[@ast::item]) -> ~[@ast::item] {
         let mut result = ~[];
-        for in_items.iter().advance |item| {
+        foreach item in in_items.iter() {
             result.push(*item);
             match item.node {
                 ast::item_struct(struct_def, ref generics) => {
@@ -322,11 +322,11 @@ impl<'self> TraitDef<'self> {
 
         let mut trait_generics = self.generics.to_generics(cx, span, type_ident, generics);
         // Copy the lifetimes
-        for generics.lifetimes.iter().advance |l| {
+        foreach l in generics.lifetimes.iter() {
             trait_generics.lifetimes.push(*l)
         };
         // Create the type parameters.
-        for generics.ty_params.iter().advance |ty_param| {
+        foreach ty_param in generics.ty_params.iter() {
             // I don't think this can be moved out of the loop, since
             // a TyParamBound requires an ast id
             let mut bounds = opt_vec::from(
@@ -486,7 +486,7 @@ impl<'self> MethodDef<'self> {
             None => respan(span, ast::sty_static),
         };
 
-        for self.args.iter().enumerate().advance |(i, ty)| {
+        foreach (i, ty) in self.args.iter().enumerate() {
             let ast_ty = ty.to_ty(cx, span, type_ident, generics);
             let ident = cx.ident_of(fmt!("__arg_%u", i));
             arg_tys.push((ident, ast_ty));
@@ -615,7 +615,7 @@ impl<'self> MethodDef<'self> {
         // make a series of nested matches, to destructure the
         // structs. This is actually right-to-left, but it shoudn't
         // matter.
-        for self_args.iter().zip(patterns.iter()).advance |(&arg_expr, &pat)| {
+        foreach (&arg_expr, &pat) in self_args.iter().zip(patterns.iter()) {
             body = cx.expr_match(span, arg_expr,
                                  ~[ cx.arm(span, ~[pat], body) ])
         }
@@ -739,10 +739,10 @@ impl<'self> MethodDef<'self> {
 
                     let mut enum_matching_fields = vec::from_elem(self_vec.len(), ~[]);
 
-                    for matches_so_far.tail().iter().advance |triple| {
+                    foreach triple in matches_so_far.tail().iter() {
                         match triple {
                             &(_, _, ref other_fields) => {
-                                for other_fields.iter().enumerate().advance |(i, pair)| {
+                                foreach (i, pair) in other_fields.iter().enumerate() {
                                     enum_matching_fields[i].push(pair.second());
                                 }
                             }
@@ -815,7 +815,7 @@ impl<'self> MethodDef<'self> {
                 }
             } else {
                 // create an arm matching on each variant
-                for enum_def.variants.iter().enumerate().advance |(index, variant)| {
+                foreach (index, variant) in enum_def.variants.iter().enumerate() {
                     let (pattern, idents) = create_enum_variant_pattern(cx, span,
                                                                        variant,
                                                                        current_match_str,
@@ -878,7 +878,7 @@ fn summarise_struct(cx: @ExtCtxt, span: span,
                     struct_def: &struct_def) -> Either<uint, ~[ident]> {
     let mut named_idents = ~[];
     let mut unnamed_count = 0;
-    for struct_def.fields.iter().advance |field| {
+    foreach field in struct_def.fields.iter() {
         match field.node.kind {
             ast::named_field(ident, _) => named_idents.push(ident),
             ast::unnamed_field => unnamed_count += 1,
@@ -932,7 +932,7 @@ fn create_struct_pattern(cx: @ExtCtxt,
     let mut ident_expr = ~[];
     let mut struct_type = Unknown;
 
-    for struct_def.fields.iter().enumerate().advance |(i, struct_field)| {
+    foreach (i, struct_field) in struct_def.fields.iter().enumerate() {
         let opt_id = match struct_field.node.kind {
             ast::named_field(ident, _) if (struct_type == Unknown ||
                                            struct_type == Record) => {
@@ -960,7 +960,7 @@ fn create_struct_pattern(cx: @ExtCtxt,
     // must be nonempty to reach here
     let pattern = if struct_type == Record {
         let field_pats = do vec::build |push| {
-            for subpats.iter().zip(ident_expr.iter()).advance |(&pat, &(id, _))| {
+            foreach (&pat, &(id, _)) in subpats.iter().zip(ident_expr.iter()) {
                 // id is guaranteed to be Some
                 push(ast::field_pat { ident: id.get(), pat: pat })
             }
diff --git a/src/libsyntax/ext/deriving/iter_bytes.rs b/src/libsyntax/ext/deriving/iter_bytes.rs
index 57a4f0899b5..215d5ca837d 100644
--- a/src/libsyntax/ext/deriving/iter_bytes.rs
+++ b/src/libsyntax/ext/deriving/iter_bytes.rs
@@ -81,7 +81,7 @@ fn iter_bytes_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @
         _ => cx.span_bug(span, "Impossible substructure in `deriving(IterBytes)`")
     }
 
-    for fields.iter().advance |&(_, field, _)| {
+    foreach &(_, field, _) in fields.iter() {
         exprs.push(call_iterbytes(field));
     }
 
diff --git a/src/libsyntax/ext/deriving/to_str.rs b/src/libsyntax/ext/deriving/to_str.rs
index 9b544eb0796..5a1a847fbc0 100644
--- a/src/libsyntax/ext/deriving/to_str.rs
+++ b/src/libsyntax/ext/deriving/to_str.rs
@@ -64,7 +64,7 @@ fn to_str_substructure(cx: @ExtCtxt, span: span,
                 stmts.push(cx.stmt_expr(call));
             };
 
-            for fields.iter().enumerate().advance |(i, &(name, e, _))| {
+            foreach (i, &(name, e, _)) in fields.iter().enumerate() {
                 if i > 0 {
                     push(cx.expr_str(span, @", "));
                 }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 4855911b9a8..dc096a145cc 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -535,7 +535,7 @@ pub fn new_name_finder() -> @Visitor<@mut ~[ast::ident]> {
                         _ => ()
                     }
                     // visit optional subpattern of pat_ident:
-                    for inner.iter().advance |subpat: &@ast::pat| {
+                    foreach subpat in inner.iter() {
                         (v.visit_pat)(*subpat, (ident_accum, v))
                     }
                 }
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index 855cf47111a..d8d114d1338 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -67,7 +67,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
     fn make_rt_conv_expr(cx: @ExtCtxt, sp: span, cnv: &Conv) -> @ast::expr {
         fn make_flags(cx: @ExtCtxt, sp: span, flags: &[Flag]) -> @ast::expr {
             let mut tmp_expr = make_rt_path_expr(cx, sp, "flag_none");
-            for flags.iter().advance |f| {
+            foreach f in flags.iter() {
                 let fstr = match *f {
                   FlagLeftJustify => "flag_left_justify",
                   FlagLeftZeroPad => "flag_left_zero_pad",
@@ -153,7 +153,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
           option::None => (),
           _ => cx.span_unimpl(sp, unsupported)
         }
-        for cnv.flags.iter().advance |f| {
+        foreach f in cnv.flags.iter() {
             match *f {
               FlagLeftJustify => (),
               FlagSignAlways => {
@@ -203,7 +203,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
           Some(p) => { debug!("param: %s", p.to_str()); }
           _ => debug!("param: none")
         }
-        for c.flags.iter().advance |f| {
+        foreach f in c.flags.iter() {
             match *f {
               FlagLeftJustify => debug!("flag: left justify"),
               FlagLeftZeroPad => debug!("flag: left zero pad"),
@@ -269,7 +269,7 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
        corresponding function in std::unstable::extfmt. Each function takes a
        buffer to insert data into along with the data being formatted. */
     let npieces = pieces.len();
-    for pieces.consume_iter().enumerate().advance |(i, pc)| {
+    foreach (i, pc) in pieces.consume_iter().enumerate() {
         match pc {
             /* Raw strings get appended via str::push_str */
             PieceString(s) => {
diff --git a/src/libsyntax/ext/pipes/liveness.rs b/src/libsyntax/ext/pipes/liveness.rs
index 6a8f3c89a2f..b080a730f3e 100644
--- a/src/libsyntax/ext/pipes/liveness.rs
+++ b/src/libsyntax/ext/pipes/liveness.rs
@@ -59,7 +59,7 @@ pub fn analyze(proto: @mut protocol_, _cx: @ExtCtxt) {
         changed = false;
         debug!("colive iteration %?", i);
         let mut new_colive = ~[];
-        for colive.iter().enumerate().advance |(i, this_colive)| {
+        foreach (i, this_colive) in colive.iter().enumerate() {
             let mut result = this_colive.clone();
             let this = proto.get_state_by_id(i);
             for this_colive.ones |j| {
@@ -78,7 +78,7 @@ pub fn analyze(proto: @mut protocol_, _cx: @ExtCtxt) {
 
     // Determine if we're bounded
     let mut self_live = ~[];
-    for colive.iter().enumerate().advance |(i, bv)| {
+    foreach (i, bv) in colive.iter().enumerate() {
         if bv.get(i) {
             self_live.push(proto.get_state_by_id(i))
         }
diff --git a/src/libsyntax/ext/pipes/pipec.rs b/src/libsyntax/ext/pipes/pipec.rs
index b046c99d144..02aef13a3a8 100644
--- a/src/libsyntax/ext/pipes/pipec.rs
+++ b/src/libsyntax/ext/pipes/pipec.rs
@@ -210,7 +210,7 @@ impl to_type_decls for state {
 
         let mut items_msg = ~[];
 
-        for self.messages.iter().advance |m| {
+        foreach m in self.messages.iter() {
             let message(name, span, tys, this, next) = (*m).clone();
 
             let tys = match next {
@@ -257,7 +257,7 @@ impl to_type_decls for state {
         let mut items = ~[];
 
         {
-            for self.messages.mut_iter().advance |m| {
+            foreach m in self.messages.mut_iter() {
                 if dir == send {
                     items.push(m.gen_send(cx, true));
                     items.push(m.gen_send(cx, false));
@@ -373,8 +373,8 @@ impl gen_init for protocol {
 
     fn buffer_ty_path(&self, cx: @ExtCtxt) -> ast::Ty {
         let mut params: OptVec<ast::TyParam> = opt_vec::Empty;
-        for self.states.iter().advance |s| {
-            for s.generics.ty_params.iter().advance |tp| {
+        foreach s in self.states.iter() {
+            foreach tp in s.generics.ty_params.iter() {
                 match params.iter().find_(|tpp| tp.ident == tpp.ident) {
                   None => params.push((*tp).clone()),
                   _ => ()
@@ -392,7 +392,7 @@ impl gen_init for protocol {
         let ext_cx = cx;
         let mut params: OptVec<ast::TyParam> = opt_vec::Empty;
         let fields = do self.states.iter().transform |s| {
-            for s.generics.ty_params.iter().advance |tp| {
+            foreach tp in s.generics.ty_params.iter() {
                 match params.iter().find_(|tpp| tp.ident == tpp.ident) {
                   None => params.push((*tp).clone()),
                   _ => ()
@@ -434,7 +434,7 @@ impl gen_init for protocol {
         let mut client_states = ~[];
         let mut server_states = ~[];
 
-        for self.states.iter().advance |s| {
+        foreach s in self.states.iter() {
             items.push_all_move(s.to_type_decls(cx));
 
             client_states.push_all_move(s.to_endpoint_decls(cx, send));
diff --git a/src/libsyntax/ext/pipes/proto.rs b/src/libsyntax/ext/pipes/proto.rs
index c93b89daa40..5d2ebb68b8a 100644
--- a/src/libsyntax/ext/pipes/proto.rs
+++ b/src/libsyntax/ext/pipes/proto.rs
@@ -107,7 +107,7 @@ impl state_ {
     /// Iterate over the states that can be reached in one message
     /// from this state.
     pub fn reachable(&self, f: &fn(state) -> bool) -> bool {
-        for self.messages.iter().advance |m| {
+        foreach m in self.messages.iter() {
             match *m {
               message(_, _, _, _, Some(next_state { state: ref id, _ })) => {
                 let state = self.proto.get_state((*id));
@@ -166,7 +166,7 @@ impl protocol_ {
     }
 
     pub fn has_ty_params(&self) -> bool {
-        for self.states.iter().advance |s| {
+        foreach s in self.states.iter() {
             if s.generics.ty_params.len() > 0 {
                 return true;
             }
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index 1439f4cabab..bcfd898dc6f 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -632,7 +632,7 @@ fn mk_tt(cx: @ExtCtxt, sp: span, tt: &ast::token_tree)
 fn mk_tts(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
     -> ~[@ast::stmt] {
     let mut ss = ~[];
-    for tts.iter().advance |tt| {
+    foreach tt in tts.iter() {
         ss.push_all_move(mk_tt(cx, sp, tt));
     }
     ss
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index 9d9155ff0d5..66965f00215 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -138,7 +138,7 @@ pub fn count_names(ms: &[matcher]) -> uint {
 pub fn initial_matcher_pos(ms: ~[matcher], sep: Option<Token>, lo: BytePos)
                         -> ~MatcherPos {
     let mut match_idx_hi = 0u;
-    for ms.iter().advance |elt| {
+    foreach elt in ms.iter() {
         match elt.node {
           match_tok(_) => (),
           match_seq(_,_,_,_,hi) => {
@@ -195,7 +195,7 @@ pub fn nameize(p_s: @mut ParseSess, ms: &[matcher], res: &[@named_match])
         match *m {
           codemap::spanned {node: match_tok(_), _} => (),
           codemap::spanned {node: match_seq(ref more_ms, _, _, _, _), _} => {
-            for more_ms.iter().advance |next_m| {
+            foreach next_m in more_ms.iter() {
                 n_rec(p_s, next_m, res, ret_val)
             };
           }
@@ -211,7 +211,7 @@ pub fn nameize(p_s: @mut ParseSess, ms: &[matcher], res: &[@named_match])
         }
     }
     let mut ret_val = HashMap::new();
-    for ms.iter().advance |m| { n_rec(p_s, m, res, &mut ret_val) }
+    foreach m in ms.iter() { n_rec(p_s, m, res, &mut ret_val) }
     ret_val
 }
 
@@ -356,7 +356,7 @@ pub fn parse(
         if tok == EOF {
             if eof_eis.len() == 1u {
                 let mut v = ~[];
-                for eof_eis[0u].matches.mut_iter().advance |dv| {
+                foreach dv in eof_eis[0u].matches.mut_iter() {
                     v.push(dv.pop());
                 }
                 return success(nameize(sess, ms, v));
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 4b3c8498380..304cf4756e1 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -93,7 +93,7 @@ pub fn add_new_extension(cx: @ExtCtxt,
 
         let s_d = cx.parse_sess().span_diagnostic;
 
-        for lhses.iter().enumerate().advance |(i, lhs)| { // try each arm's matchers
+        foreach (i, lhs) in lhses.iter().enumerate() { // try each arm's matchers
             match *lhs {
               @matched_nonterminal(nt_matchers(ref mtcs)) => {
                 // `none` is because we're not interpolating
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index e3ca36ac12d..f0b00f5681c 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -380,7 +380,7 @@ fn noop_fold_method(m: @method, fld: @ast_fold) -> @method {
 pub fn noop_fold_block(b: &Block, fld: @ast_fold) -> Block {
     let view_items = b.view_items.map(|x| fld.fold_view_item(x));
     let mut stmts = ~[];
-    for b.stmts.iter().advance |stmt| {
+    foreach stmt in b.stmts.iter() {
         match fld.fold_stmt(*stmt) {
             None => {}
             Some(stmt) => stmts.push(stmt)
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index 6daeb1b3e1e..c5454a2ca95 100644
--- a/src/libsyntax/parse/comments.rs
+++ b/src/libsyntax/parse/comments.rs
@@ -73,8 +73,8 @@ pub fn strip_doc_comment_decoration(comment: &str) -> ~str {
         let mut i = uint::max_value;
         let mut can_trim = true;
         let mut first = true;
-        for lines.iter().advance |line| {
-            for line.iter().enumerate().advance |(j, c)| {
+        foreach line in lines.iter() {
+            foreach (j, c) in line.iter().enumerate() {
                 if j > i || !"* \t".contains_char(c) {
                     can_trim = false;
                     break;
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 1614a303d95..3259d49fcd1 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -837,7 +837,7 @@ mod test {
     // check that the given reader produces the desired stream
     // of tokens (stop checking after exhausting the expected vec)
     fn check_tokenization (env: Env, expected: ~[token::Token]) {
-        for expected.iter().advance |expected_tok| {
+        foreach expected_tok in expected.iter() {
             let TokenAndSpan {tok:actual_tok, sp: _} =
                 env.string_reader.next_token();
             assert_eq!(&actual_tok,expected_tok);
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 9444c463686..1d61c5be83d 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -3150,7 +3150,7 @@ impl Parser {
         } = self.parse_items_and_view_items(first_item_attrs,
                                             false, false);
 
-        for items.iter().advance |item| {
+        foreach item in items.iter() {
             let decl = @spanned(item.span.lo, item.span.hi, decl_item(*item));
             stmts.push(@spanned(item.span.lo, item.span.hi,
                                 stmt_decl(decl, self.get_id())));
@@ -3755,7 +3755,7 @@ impl Parser {
             fields = ~[];
             while *self.token != token::RBRACE {
                 let r = self.parse_struct_decl_field();
-                for r.iter().advance |struct_field| {
+                foreach struct_field in r.iter() {
                     fields.push(*struct_field)
                 }
             }
@@ -4038,7 +4038,7 @@ impl Parser {
             Some(i) => {
                 let stack = &self.sess.included_mod_stack;
                 let mut err = ~"circular modules: ";
-                for stack.slice(i, stack.len()).iter().advance |p| {
+                foreach p in stack.slice(i, stack.len()).iter() {
                     err.push_str(p.to_str());
                     err.push_str(" -> ");
                 }
@@ -4246,7 +4246,7 @@ impl Parser {
         let mut fields: ~[@struct_field] = ~[];
         while *self.token != token::RBRACE {
             let r = self.parse_struct_decl_field();
-            for r.iter().advance |struct_field| {
+            foreach struct_field in r.iter() {
                 fields.push(*struct_field);
             }
         }
@@ -4286,7 +4286,7 @@ impl Parser {
                     seq_sep_trailing_disallowed(token::COMMA),
                     |p| p.parse_ty(false)
                 );
-                for arg_tys.consume_iter().advance |ty| {
+                foreach ty in arg_tys.consume_iter() {
                     args.push(ast::variant_arg {
                         ty: ty,
                         id: self.get_id(),
@@ -4395,7 +4395,7 @@ impl Parser {
                 self.bump();
                 let the_string = ident_to_str(&s);
                 let mut abis = AbiSet::empty();
-                for the_string.word_iter().advance |word| {
+                foreach word in the_string.word_iter() {
                     match abi::lookup(word) {
                         Some(abi) => {
                             if abis.contains(abi) {
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 3365222036c..706357320a5 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -687,7 +687,6 @@ pub fn is_reserved_keyword(tok: &Token) -> bool {
 #[cfg(test)]
 mod test {
     use super::*;
-    use std::io;
     #[test] fn t1() {
         let a = fresh_name("ghi");
         printfln!("interned name: %u,\ntextual name: %s\n",
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 7e0e63a29ac..a4666847f8c 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -321,7 +321,7 @@ pub fn synth_comment(s: @ps, text: ~str) {
 pub fn commasep<T>(s: @ps, b: breaks, elts: &[T], op: &fn(@ps, &T)) {
     box(s, 0u, b);
     let mut first = true;
-    for elts.iter().advance |elt| {
+    foreach elt in elts.iter() {
         if first { first = false; } else { word_space(s, ","); }
         op(s, elt);
     }
@@ -334,7 +334,7 @@ pub fn commasep_cmnt<T>(s: @ps, b: breaks, elts: &[T], op: &fn(@ps, &T),
     box(s, 0u, b);
     let len = elts.len();
     let mut i = 0u;
-    for elts.iter().advance |elt| {
+    foreach elt in elts.iter() {
         maybe_print_comment(s, get_span(elt).hi);
         op(s, elt);
         i += 1u;
@@ -354,23 +354,23 @@ pub fn commasep_exprs(s: @ps, b: breaks, exprs: &[@ast::expr]) {
 
 pub fn print_mod(s: @ps, _mod: &ast::_mod, attrs: &[ast::Attribute]) {
     print_inner_attributes(s, attrs);
-    for _mod.view_items.iter().advance |vitem| {
+    foreach vitem in _mod.view_items.iter() {
         print_view_item(s, vitem);
     }
-    for _mod.items.iter().advance |item| { print_item(s, *item); }
+    foreach item in _mod.items.iter() { print_item(s, *item); }
 }
 
 pub fn print_foreign_mod(s: @ps, nmod: &ast::foreign_mod,
                          attrs: &[ast::Attribute]) {
     print_inner_attributes(s, attrs);
-    for nmod.view_items.iter().advance |vitem| {
+    foreach vitem in nmod.view_items.iter() {
         print_view_item(s, vitem);
     }
-    for nmod.items.iter().advance |item| { print_foreign_item(s, *item); }
+    foreach item in nmod.items.iter() { print_foreign_item(s, *item); }
 }
 
 pub fn print_opt_lifetime(s: @ps, lifetime: &Option<ast::Lifetime>) {
-    for lifetime.iter().advance |l| {
+    foreach l in lifetime.iter() {
         print_lifetime(s, l);
         nbsp(s);
     }
@@ -590,7 +590,7 @@ pub fn print_item(s: @ps, item: &ast::item) {
             word(s.s, ";");
         } else {
             bopen(s);
-            for methods.iter().advance |meth| {
+            foreach meth in methods.iter() {
                print_method(s, *meth);
             }
             bclose(s, item.span);
@@ -602,7 +602,7 @@ pub fn print_item(s: @ps, item: &ast::item) {
         print_generics(s, generics);
         if traits.len() != 0u {
             word(s.s, ":");
-            for traits.iter().enumerate().advance |(i, trait_)| {
+            foreach (i, trait_) in traits.iter().enumerate() {
                 nbsp(s);
                 if i != 0 {
                     word_space(s, "+");
@@ -612,7 +612,7 @@ pub fn print_item(s: @ps, item: &ast::item) {
         }
         word(s.s, " ");
         bopen(s);
-        for methods.iter().advance |meth| {
+        foreach meth in methods.iter() {
             print_trait_method(s, meth);
         }
         bclose(s, item.span);
@@ -651,7 +651,7 @@ pub fn print_variants(s: @ps,
                       variants: &[ast::variant],
                       span: codemap::span) {
     bopen(s);
-    for variants.iter().advance |v| {
+    foreach v in variants.iter() {
         space_if_not_bol(s);
         maybe_print_comment(s, v.span.lo);
         print_outer_attributes(s, v.node.attrs);
@@ -716,7 +716,7 @@ pub fn print_struct(s: @ps,
         bopen(s);
         hardbreak_if_not_bol(s);
 
-        for struct_def.fields.iter().advance |field| {
+        foreach field in struct_def.fields.iter() {
             match field.node.kind {
                 ast::unnamed_field => fail!("unexpected unnamed field"),
                 ast::named_field(ident, visibility) => {
@@ -751,7 +751,7 @@ pub fn print_tt(s: @ps, tt: &ast::token_tree) {
       }
       ast::tt_seq(_, ref tts, ref sep, zerok) => {
         word(s.s, "$(");
-        for (*tts).iter().advance |tt_elt| { print_tt(s, tt_elt); }
+        foreach tt_elt in (*tts).iter() { print_tt(s, tt_elt); }
         word(s.s, ")");
         match (*sep) {
           Some(ref tk) => word(s.s, parse::token::to_str(s.intr, tk)),
@@ -768,7 +768,7 @@ pub fn print_tt(s: @ps, tt: &ast::token_tree) {
 
 pub fn print_tts(s: @ps, tts: & &[ast::token_tree]) {
     ibox(s, 0);
-    for tts.iter().enumerate().advance |(i, tt)| {
+    foreach (i, tt) in tts.iter().enumerate() {
         if i != 0 {
             space(s.s);
         }
@@ -845,7 +845,7 @@ pub fn print_method(s: @ps, meth: &ast::method) {
 
 pub fn print_outer_attributes(s: @ps, attrs: &[ast::Attribute]) {
     let mut count = 0;
-    for attrs.iter().advance |attr| {
+    foreach attr in attrs.iter() {
         match attr.node.style {
           ast::AttrOuter => { print_attribute(s, attr); count += 1; }
           _ => {/* fallthrough */ }
@@ -856,7 +856,7 @@ pub fn print_outer_attributes(s: @ps, attrs: &[ast::Attribute]) {
 
 pub fn print_inner_attributes(s: @ps, attrs: &[ast::Attribute]) {
     let mut count = 0;
-    for attrs.iter().advance |attr| {
+    foreach attr in attrs.iter() {
         match attr.node.style {
           ast::AttrInner => {
             print_attribute(s, attr);
@@ -961,8 +961,8 @@ pub fn print_possibly_embedded_block_(s: @ps,
 
     print_inner_attributes(s, attrs);
 
-    for blk.view_items.iter().advance |vi| { print_view_item(s, vi); }
-    for blk.stmts.iter().advance |st| {
+    foreach vi in blk.view_items.iter() { print_view_item(s, vi); }
+    foreach st in blk.stmts.iter() {
         print_stmt(s, *st);
     }
     match blk.expr {
@@ -1238,7 +1238,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
         print_block(s, blk);
       }
       ast::expr_loop(ref blk, opt_ident) => {
-        for opt_ident.iter().advance |ident| {
+        foreach ident in opt_ident.iter() {
             word(s.s, "'");
             print_ident(s, *ident);
             word_space(s, ":");
@@ -1255,12 +1255,12 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
         space(s.s);
         bopen(s);
         let len = arms.len();
-        for arms.iter().enumerate().advance |(i, arm)| {
+        foreach (i, arm) in arms.iter().enumerate() {
             space(s.s);
             cbox(s, indent_unit);
             ibox(s, 0u);
             let mut first = true;
-            for arm.pats.iter().advance |p| {
+            foreach p in arm.pats.iter() {
                 if first {
                     first = false;
                 } else { space(s.s); word_space(s, "|"); }
@@ -1386,7 +1386,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
       ast::expr_break(opt_ident) => {
         word(s.s, "break");
         space(s.s);
-        for opt_ident.iter().advance |ident| {
+        foreach ident in opt_ident.iter() {
             word(s.s, "'");
             print_ident(s, *ident);
             space(s.s);
@@ -1395,7 +1395,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
       ast::expr_again(opt_ident) => {
         word(s.s, "loop");
         space(s.s);
-        for opt_ident.iter().advance |ident| {
+        foreach ident in opt_ident.iter() {
             word(s.s, "'");
             print_ident(s, *ident);
             space(s.s)
@@ -1426,7 +1426,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
         popen(s);
         print_string(s, a.asm);
         word_space(s, ":");
-        for a.outputs.iter().advance |&(co, o)| {
+        foreach &(co, o) in a.outputs.iter() {
             print_string(s, co);
             popen(s);
             print_expr(s, o);
@@ -1434,7 +1434,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
             word_space(s, ",");
         }
         word_space(s, ":");
-        for a.inputs.iter().advance |&(co, o)| {
+        foreach &(co, o) in a.inputs.iter() {
             print_string(s, co);
             popen(s);
             print_expr(s, o);
@@ -1513,7 +1513,7 @@ fn print_path_(s: @ps, path: &ast::Path, colons_before_params: bool,
     maybe_print_comment(s, path.span.lo);
     if path.global { word(s.s, "::"); }
     let mut first = true;
-    for path.idents.iter().advance |id| {
+    foreach id in path.idents.iter() {
         if first { first = false; } else { word(s.s, "::"); }
         print_ident(s, *id);
     }
@@ -1526,7 +1526,7 @@ fn print_path_(s: @ps, path: &ast::Path, colons_before_params: bool,
         if path.rp.is_some() || !path.types.is_empty() {
             word(s.s, "<");
 
-            for path.rp.iter().advance |r| {
+            foreach r in path.rp.iter() {
                 print_lifetime(s, r);
                 if !path.types.is_empty() {
                     word_space(s, ",");
@@ -1640,7 +1640,7 @@ pub fn print_pat(s: @ps, pat: &ast::pat) {
         do commasep(s, inconsistent, *before) |s, &p| {
             print_pat(s, p);
         }
-        for slice.iter().advance |&p| {
+        foreach &p in slice.iter() {
             if !before.is_empty() { word_space(s, ","); }
             word(s.s, "..");
             print_pat(s, p);
@@ -1700,11 +1700,11 @@ pub fn print_fn_args(s: @ps, decl: &ast::fn_decl,
     // self type and the args all in the same box.
     box(s, 0u, inconsistent);
     let mut first = true;
-    for opt_explicit_self.iter().advance |explicit_self| {
+    foreach explicit_self in opt_explicit_self.iter() {
         first = !print_explicit_self(s, *explicit_self);
     }
 
-    for decl.inputs.iter().advance |arg| {
+    foreach arg in decl.inputs.iter() {
         if first { first = false; } else { word_space(s, ","); }
         print_arg(s, arg);
     }
@@ -1751,7 +1751,7 @@ pub fn print_bounds(s: @ps, bounds: &OptVec<ast::TyParamBound>,
     if !bounds.is_empty() {
         word(s.s, ":");
         let mut first = true;
-        for bounds.iter().advance |bound| {
+        foreach bound in bounds.iter() {
             nbsp(s);
             if first {
                 first = false;
@@ -1950,10 +1950,10 @@ pub fn print_ty_fn(s: @ps,
     // self type and the args all in the same box.
     box(s, 0u, inconsistent);
     let mut first = true;
-    for opt_explicit_self.iter().advance |explicit_self| {
+    foreach explicit_self in opt_explicit_self.iter() {
         first = !print_explicit_self(s, *explicit_self);
     }
-    for decl.inputs.iter().advance |arg| {
+    foreach arg in decl.inputs.iter() {
         if first { first = false; } else { word_space(s, ","); }
         print_arg(s, arg);
     }
@@ -2109,7 +2109,7 @@ pub fn print_comment(s: @ps, cmnt: &comments::cmnt) {
       }
       comments::isolated => {
         pprust::hardbreak_if_not_bol(s);
-        for cmnt.lines.iter().advance |line| {
+        foreach line in cmnt.lines.iter() {
             // Don't print empty lines because they will end up as trailing
             // whitespace
             if !line.is_empty() { word(s.s, *line); }
@@ -2123,7 +2123,7 @@ pub fn print_comment(s: @ps, cmnt: &comments::cmnt) {
             hardbreak(s.s);
         } else {
             ibox(s, 0u);
-            for cmnt.lines.iter().advance |line| {
+            foreach line in cmnt.lines.iter() {
                 if !line.is_empty() { word(s.s, *line); }
                 hardbreak(s.s);
             }
diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs
index 014186c9ff4..b9c8c3f4e4c 100644
--- a/src/libsyntax/util/interner.rs
+++ b/src/libsyntax/util/interner.rs
@@ -31,7 +31,7 @@ impl<T:Eq + IterBytes + Hash + Freeze + Clone + 'static> Interner<T> {
 
     pub fn prefill(init: &[T]) -> Interner<T> {
         let rv = Interner::new();
-        for init.iter().advance |v| {
+        foreach v in init.iter() {
             rv.intern((*v).clone());
         }
         rv
@@ -93,7 +93,7 @@ impl StrInterner {
 
     pub fn prefill(init: &[&str]) -> StrInterner {
         let rv = StrInterner::new();
-        for init.iter().advance |&v| { rv.intern(v); }
+        foreach &v in init.iter() { rv.intern(v); }
         rv
     }
 
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 07749c7254b..d988f96d3d4 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -126,10 +126,10 @@ pub fn visit_mod<E:Clone>(m: &_mod,
                           _sp: span,
                           _id: NodeId,
                           (e, v): (E, vt<E>)) {
-    for m.view_items.iter().advance |vi| {
+    foreach vi in m.view_items.iter() {
         (v.visit_view_item)(vi, (e.clone(), v));
     }
-    for m.items.iter().advance |i| {
+    foreach i in m.items.iter() {
         (v.visit_item)(*i, (e.clone(), v));
     }
 }
@@ -173,10 +173,10 @@ pub fn visit_item<E:Clone>(i: &item, (e, v): (E, vt<E>)) {
         }
         item_mod(ref m) => (v.visit_mod)(m, i.span, i.id, (e, v)),
         item_foreign_mod(ref nm) => {
-            for nm.view_items.iter().advance |vi| {
+            foreach vi in nm.view_items.iter() {
                 (v.visit_view_item)(vi, (e.clone(), v));
             }
-            for nm.items.iter().advance |ni| {
+            foreach ni in nm.items.iter() {
                 (v.visit_foreign_item)(*ni, (e.clone(), v));
             }
         }
@@ -194,11 +194,11 @@ pub fn visit_item<E:Clone>(i: &item, (e, v): (E, vt<E>)) {
         }
         item_impl(ref tps, ref traits, ref ty, ref methods) => {
             (v.visit_generics)(tps, (e.clone(), v));
-            for traits.iter().advance |p| {
+            foreach p in traits.iter() {
                 visit_trait_ref(p, (e.clone(), v));
             }
             (v.visit_ty)(ty, (e.clone(), v));
-            for methods.iter().advance |m| {
+            foreach m in methods.iter() {
                 visit_method_helper(*m, (e.clone(), v))
             }
         }
@@ -208,10 +208,10 @@ pub fn visit_item<E:Clone>(i: &item, (e, v): (E, vt<E>)) {
         }
         item_trait(ref generics, ref traits, ref methods) => {
             (v.visit_generics)(generics, (e.clone(), v));
-            for traits.iter().advance |p| {
+            foreach p in traits.iter() {
                 visit_path(&p.path, (e.clone(), v));
             }
-            for methods.iter().advance |m| {
+            foreach m in methods.iter() {
                 (v.visit_trait_method)(m, (e.clone(), v));
             }
         }
@@ -222,10 +222,10 @@ pub fn visit_item<E:Clone>(i: &item, (e, v): (E, vt<E>)) {
 pub fn visit_enum_def<E:Clone>(enum_definition: &ast::enum_def,
                                tps: &Generics,
                                (e, v): (E, vt<E>)) {
-    for enum_definition.variants.iter().advance |vr| {
+    foreach vr in enum_definition.variants.iter() {
         match vr.node.kind {
             tuple_variant_kind(ref variant_args) => {
-                for variant_args.iter().advance |va| {
+                foreach va in variant_args.iter() {
                     (v.visit_ty)(&va.ty, (e.clone(), v));
                 }
             }
@@ -235,7 +235,7 @@ pub fn visit_enum_def<E:Clone>(enum_definition: &ast::enum_def,
             }
         }
         // Visit the disr expr if it exists
-        for vr.node.disr_expr.iter().advance |ex| {
+        foreach ex in vr.node.disr_expr.iter() {
             (v.visit_expr)(*ex, (e.clone(), v))
         }
     }
@@ -250,12 +250,12 @@ pub fn visit_ty<E:Clone>(t: &Ty, (e, v): (E, vt<E>)) {
             (v.visit_ty)(mt.ty, (e, v));
         },
         ty_tup(ref ts) => {
-            for ts.iter().advance |tt| {
+            foreach tt in ts.iter() {
                 (v.visit_ty)(tt, (e.clone(), v));
             }
         },
         ty_closure(ref f) => {
-            for f.decl.inputs.iter().advance |a| {
+            foreach a in f.decl.inputs.iter() {
                 (v.visit_ty)(&a.ty, (e.clone(), v));
             }
             (v.visit_ty)(&f.decl.output, (e.clone(), v));
@@ -264,7 +264,7 @@ pub fn visit_ty<E:Clone>(t: &Ty, (e, v): (E, vt<E>)) {
             };
         },
         ty_bare_fn(ref f) => {
-            for f.decl.inputs.iter().advance |a| {
+            foreach a in f.decl.inputs.iter() {
                 (v.visit_ty)(&a.ty, (e.clone(), v));
             }
             (v.visit_ty)(&f.decl.output, (e, v));
@@ -284,27 +284,27 @@ pub fn visit_ty<E:Clone>(t: &Ty, (e, v): (E, vt<E>)) {
 }
 
 pub fn visit_path<E:Clone>(p: &Path, (e, v): (E, vt<E>)) {
-    for p.types.iter().advance |tp| { (v.visit_ty)(tp, (e.clone(), v)); }
+    foreach tp in p.types.iter() { (v.visit_ty)(tp, (e.clone(), v)); }
 }
 
 pub fn visit_pat<E:Clone>(p: &pat, (e, v): (E, vt<E>)) {
     match p.node {
         pat_enum(ref path, ref children) => {
             visit_path(path, (e.clone(), v));
-            for children.iter().advance |children| {
-                for children.iter().advance |child| {
+            foreach children in children.iter() {
+                foreach child in children.iter() {
                     (v.visit_pat)(*child, (e.clone(), v));
                 }
             }
         }
         pat_struct(ref path, ref fields, _) => {
             visit_path(path, (e.clone(), v));
-            for fields.iter().advance |f| {
+            foreach f in fields.iter() {
                 (v.visit_pat)(f.pat, (e.clone(), v));
             }
         }
         pat_tup(ref elts) => {
-            for elts.iter().advance |elt| {
+            foreach elt in elts.iter() {
                 (v.visit_pat)(*elt, (e.clone(), v))
             }
         },
@@ -313,7 +313,7 @@ pub fn visit_pat<E:Clone>(p: &pat, (e, v): (E, vt<E>)) {
         },
         pat_ident(_, ref path, ref inner) => {
             visit_path(path, (e.clone(), v));
-            for inner.iter().advance |subpat| {
+            foreach subpat in inner.iter() {
                 (v.visit_pat)(*subpat, (e.clone(), v))
             }
         }
@@ -324,13 +324,13 @@ pub fn visit_pat<E:Clone>(p: &pat, (e, v): (E, vt<E>)) {
         }
         pat_wild => (),
         pat_vec(ref before, ref slice, ref after) => {
-            for before.iter().advance |elt| {
+            foreach elt in before.iter() {
                 (v.visit_pat)(*elt, (e.clone(), v));
             }
-            for slice.iter().advance |elt| {
+            foreach elt in slice.iter() {
                 (v.visit_pat)(*elt, (e.clone(), v));
             }
-            for after.iter().advance |tail| {
+            foreach tail in after.iter() {
                 (v.visit_pat)(*tail, (e.clone(), v));
             }
         }
@@ -351,7 +351,7 @@ pub fn visit_foreign_item<E:Clone>(ni: &foreign_item, (e, v): (E, vt<E>)) {
 
 pub fn visit_ty_param_bounds<E:Clone>(bounds: &OptVec<TyParamBound>,
                                       (e, v): (E, vt<E>)) {
-    for bounds.iter().advance |bound| {
+    foreach bound in bounds.iter() {
         match *bound {
             TraitTyParamBound(ref ty) => visit_trait_ref(ty, (e.clone(), v)),
             RegionTyParamBound => {}
@@ -360,13 +360,13 @@ pub fn visit_ty_param_bounds<E:Clone>(bounds: &OptVec<TyParamBound>,
 }
 
 pub fn visit_generics<E:Clone>(generics: &Generics, (e, v): (E, vt<E>)) {
-    for generics.ty_params.iter().advance |tp| {
+    foreach tp in generics.ty_params.iter() {
         visit_ty_param_bounds(&tp.bounds, (e.clone(), v));
     }
 }
 
 pub fn visit_fn_decl<E:Clone>(fd: &fn_decl, (e, v): (E, vt<E>)) {
-    for fd.inputs.iter().advance |a| {
+    foreach a in fd.inputs.iter() {
         (v.visit_pat)(a.pat, (e.clone(), v));
         (v.visit_ty)(&a.ty, (e.clone(), v));
     }
@@ -395,7 +395,7 @@ pub fn visit_fn<E:Clone>(fk: &fn_kind, decl: &fn_decl, body: &Block, _sp: span,
 }
 
 pub fn visit_ty_method<E:Clone>(m: &TypeMethod, (e, v): (E, vt<E>)) {
-    for m.decl.inputs.iter().advance |a| {
+    foreach a in m.decl.inputs.iter() {
         (v.visit_ty)(&a.ty, (e.clone(), v));
     }
     (v.visit_generics)(&m.generics, (e.clone(), v));
@@ -416,7 +416,7 @@ pub fn visit_struct_def<E:Clone>(
     _id: NodeId,
     (e, v): (E, vt<E>)
 ) {
-    for sd.fields.iter().advance |f| {
+    foreach f in sd.fields.iter() {
         (v.visit_struct_field)(*f, (e.clone(), v));
     }
 }
@@ -426,10 +426,10 @@ pub fn visit_struct_field<E:Clone>(sf: &struct_field, (e, v): (E, vt<E>)) {
 }
 
 pub fn visit_block<E:Clone>(b: &Block, (e, v): (E, vt<E>)) {
-    for b.view_items.iter().advance |vi| {
+    foreach vi in b.view_items.iter() {
         (v.visit_view_item)(vi, (e.clone(), v));
     }
-    for b.stmts.iter().advance |s| {
+    foreach s in b.stmts.iter() {
         (v.visit_stmt)(*s, (e.clone(), v));
     }
     visit_expr_opt(b.expr, (e, v));
@@ -456,7 +456,7 @@ pub fn visit_expr_opt<E>(eo: Option<@expr>, (e, v): (E, vt<E>)) {
 }
 
 pub fn visit_exprs<E:Clone>(exprs: &[@expr], (e, v): (E, vt<E>)) {
-    for exprs.iter().advance |ex| { (v.visit_expr)(*ex, (e.clone(), v)); }
+    foreach ex in exprs.iter() { (v.visit_expr)(*ex, (e.clone(), v)); }
 }
 
 pub fn visit_mac<E>(_m: &mac, (_e, _v): (E, vt<E>)) {
@@ -473,13 +473,13 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) {
         }
         expr_struct(ref p, ref flds, base) => {
             visit_path(p, (e.clone(), v));
-            for flds.iter().advance |f| {
+            foreach f in flds.iter() {
                 (v.visit_expr)(f.expr, (e.clone(), v));
             }
             visit_expr_opt(base, (e.clone(), v));
         }
         expr_tup(ref elts) => {
-            for elts.iter().advance |el| { (v.visit_expr)(*el, (e.clone(), v)) }
+            foreach el in elts.iter() { (v.visit_expr)(*el, (e.clone(), v)) }
         }
         expr_call(callee, ref args, _) => {
             visit_exprs(*args, (e.clone(), v));
@@ -487,7 +487,7 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) {
         }
         expr_method_call(_, callee, _, ref tys, ref args, _) => {
             visit_exprs(*args, (e.clone(), v));
-            for tys.iter().advance |tp| {
+            foreach tp in tys.iter() {
                 (v.visit_ty)(tp, (e.clone(), v));
             }
             (v.visit_expr)(callee, (e.clone(), v));
@@ -520,7 +520,7 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) {
         expr_loop(ref b, _) => (v.visit_block)(b, (e.clone(), v)),
         expr_match(x, ref arms) => {
             (v.visit_expr)(x, (e.clone(), v));
-            for arms.iter().advance |a| { (v.visit_arm)(a, (e.clone(), v)); }
+            foreach a in arms.iter() { (v.visit_arm)(a, (e.clone(), v)); }
         }
         expr_fn_block(ref decl, ref body) => {
             (v.visit_fn)(
@@ -543,7 +543,7 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) {
         }
         expr_field(x, _, ref tys) => {
             (v.visit_expr)(x, (e.clone(), v));
-            for tys.iter().advance |tp| {
+            foreach tp in tys.iter() {
                 (v.visit_ty)(tp, (e.clone(), v));
             }
         }
@@ -563,10 +563,10 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) {
         expr_mac(ref mac) => visit_mac(mac, (e.clone(), v)),
         expr_paren(x) => (v.visit_expr)(x, (e.clone(), v)),
         expr_inline_asm(ref a) => {
-            for a.inputs.iter().advance |&(_, input)| {
+            foreach &(_, input) in a.inputs.iter() {
                 (v.visit_expr)(input, (e.clone(), v));
             }
-            for a.outputs.iter().advance |&(_, out)| {
+            foreach &(_, out) in a.outputs.iter() {
                 (v.visit_expr)(out, (e.clone(), v));
             }
         }
@@ -575,7 +575,7 @@ pub fn visit_expr<E:Clone>(ex: @expr, (e, v): (E, vt<E>)) {
 }
 
 pub fn visit_arm<E:Clone>(a: &arm, (e, v): (E, vt<E>)) {
-    for a.pats.iter().advance |p| { (v.visit_pat)(*p, (e.clone(), v)); }
+    foreach p in a.pats.iter() { (v.visit_pat)(*p, (e.clone(), v)); }
     visit_expr_opt(a.guard, (e.clone(), v));
     (v.visit_block)(&a.body, (e.clone(), v));
 }