remove obsolete `foreach` keyword

this has been replaced by `for`

27 files changed, 199 insertions, 204 deletions

diff --git a/src/libsyntax/abi.rs b/src/libsyntax/abi.rs
index dc6919efcf9..e6bbd45dae7 100644
--- a/src/libsyntax/abi.rs
+++ b/src/libsyntax/abi.rs
@@ -217,9 +217,9 @@ impl AbiSet {
         let mut abis = ~[];
         do self.each |abi| { abis.push(abi); true };
 
-        foreach (i, abi) in abis.iter().enumerate() {
+        for (i, abi) in abis.iter().enumerate() {
             let data = abi.data();
-            foreach other_abi in abis.slice(0, i).iter() {
+            for other_abi in abis.slice(0, i).iter() {
                 let other_data = other_abi.data();
                 debug!("abis=(%?,%?) datas=(%?,%?)",
                        abi, data.abi_arch,
@@ -381,7 +381,7 @@ fn abi_to_str_rust() {
 
 #[test]
 fn indices_are_correct() {
-    foreach (i, abi_data) in AbiDatas.iter().enumerate() {
+    for (i, abi_data) in AbiDatas.iter().enumerate() {
         assert!(i == abi_data.abi.index());
     }
 
@@ -396,7 +396,7 @@ fn indices_are_correct() {
 #[cfg(test)]
 fn check_arch(abis: &[Abi], arch: Architecture, expect: Option<Abi>) {
     let mut set = AbiSet::empty();
-    foreach &abi in abis.iter() {
+    for &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 9c0f2d34a6c..5cba22a8e23 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -136,7 +136,7 @@ impl Ctx {
         // Expressions which are or might be calls:
         {
             let r = ex.get_callee_id();
-            foreach callee_id in r.iter() {
+            for callee_id in r.iter() {
                 self.map.insert(*callee_id, node_callee_scope(ex));
             }
         }
@@ -150,7 +150,7 @@ impl Ctx {
               body: &Block,
               sp: codemap::span,
               id: NodeId) {
-        foreach a in decl.inputs.iter() {
+        for a in decl.inputs.iter() {
             self.map.insert(a.id, node_arg);
         }
         visit::visit_fn(self as @Visitor<()>, fk, decl, body, sp, id, ());
@@ -189,12 +189,12 @@ impl Visitor<()> for Ctx {
         match i.node {
             item_impl(_, _, _, ref ms) => {
                 let impl_did = ast_util::local_def(i.id);
-                foreach m in ms.iter() {
+                for m in ms.iter() {
                     self.map_method(impl_did, self.extend(i.ident), *m, false)
                 }
             }
             item_enum(ref enum_definition, _) => {
-                foreach v in (*enum_definition).variants.iter() {
+                for v in (*enum_definition).variants.iter() {
                     // FIXME #2543: bad clone
                     self.map.insert(v.node.id,
                                     node_variant((*v).clone(),
@@ -203,7 +203,7 @@ impl Visitor<()> for Ctx {
                 }
             }
             item_foreign_mod(ref nm) => {
-                foreach nitem in nm.items.iter() {
+                for nitem in nm.items.iter() {
                     // Compute the visibility for this native item.
                     let visibility = match nitem.vis {
                         public => public,
@@ -233,10 +233,10 @@ impl Visitor<()> for Ctx {
                                     i.ident)
             }
             item_trait(_, ref traits, ref methods) => {
-                foreach p in traits.iter() {
+                for p in traits.iter() {
                     self.map.insert(p.ref_id, node_item(i, item_path));
                 }
-                foreach tm in methods.iter() {
+                for tm in methods.iter() {
                     let id = ast_util::trait_method_to_ty_method(tm).id;
                     let d_id = ast_util::local_def(i.id);
                     self.map.insert(id,
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 45238c30d73..11d3740be3f 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -279,7 +279,7 @@ pub fn split_trait_methods(trait_methods: &[trait_method])
     -> (~[TypeMethod], ~[@method]) {
     let mut reqd = ~[];
     let mut provd = ~[];
-    foreach trt_method in trait_methods.iter() {
+    for trt_method in trait_methods.iter() {
         match *trt_method {
           required(ref tm) => reqd.push((*tm).clone()),
           provided(m) => provd.push(m)
@@ -398,10 +398,10 @@ struct IdVisitor {
 
 impl IdVisitor {
     fn visit_generics_helper(@mut self, generics: &Generics) {
-        foreach type_parameter in generics.ty_params.iter() {
+        for type_parameter in generics.ty_params.iter() {
             (self.visit_callback)(type_parameter.id)
         }
-        foreach lifetime in generics.lifetimes.iter() {
+        for lifetime in generics.lifetimes.iter() {
             (self.visit_callback)(lifetime.id)
         }
     }
@@ -423,7 +423,7 @@ impl Visitor<()> for IdVisitor {
                 (self.visit_callback)(node_id)
             }
             view_item_use(ref view_paths) => {
-                foreach view_path in view_paths.iter() {
+                for view_path in view_paths.iter() {
                     match view_path.node {
                         view_path_simple(_, _, node_id) |
                         view_path_glob(_, node_id) => {
@@ -431,7 +431,7 @@ impl Visitor<()> for IdVisitor {
                         }
                         view_path_list(_, ref paths, node_id) => {
                             (self.visit_callback)(node_id);
-                            foreach path in paths.iter() {
+                            for path in paths.iter() {
                                 (self.visit_callback)(path.node.id)
                             }
                         }
@@ -459,7 +459,7 @@ impl Visitor<()> for IdVisitor {
         (self.visit_callback)(item.id);
         match item.node {
             item_enum(ref enum_definition, _) => {
-                foreach variant in enum_definition.variants.iter() {
+                for variant in enum_definition.variants.iter() {
                     (self.visit_callback)(variant.node.id)
                 }
             }
@@ -504,7 +504,7 @@ impl Visitor<()> for IdVisitor {
     fn visit_expr(@mut self, expression: @expr, env: ()) {
         {
             let optional_callee_id = expression.get_callee_id();
-            foreach callee_id in optional_callee_id.iter() {
+            for callee_id in optional_callee_id.iter() {
                 (self.visit_callback)(*callee_id)
             }
         }
@@ -559,7 +559,7 @@ impl Visitor<()> for IdVisitor {
             visit::fk_anon(_) | visit::fk_fn_block => {}
         }
 
-        foreach argument in function_declaration.inputs.iter() {
+        for argument in function_declaration.inputs.iter() {
             (self.visit_callback)(argument.id)
         }
 
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index 615b47e5681..d1ddebfc347 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 = ~[];
-    foreach attr in attrs.iter().filter(|at| "link" == at.name()) {
+    for 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();
-    foreach meta in metas.iter() {
+    for 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 04b9fdce666..0da424ce54c 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -363,7 +363,7 @@ impl CodeMap {
         let lo = self.lookup_char_pos(sp.lo);
         let hi = self.lookup_char_pos(sp.hi);
         let mut lines = ~[];
-        foreach i in range(lo.line - 1u, hi.line as uint) {
+        for i in range(lo.line - 1u, hi.line as uint) {
             lines.push(i);
         };
         return @FileLines {file: lo.file, lines: lines};
@@ -378,7 +378,7 @@ impl CodeMap {
     }
 
     pub fn get_filemap(&self, filename: &str) -> @FileMap {
-        foreach fm in self.files.iter() { if filename == fm.name { return *fm; } }
+        for 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");
@@ -464,7 +464,7 @@ impl CodeMap {
         // The number of extra bytes due to multibyte chars in the FileMap
         let mut total_extra_bytes = 0;
 
-        foreach mbc in map.multibyte_chars.iter() {
+        for 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 01f55e8c4f4..8b501436641 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -267,7 +267,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
         elided = true;
     }
     // Print the offending lines
-    foreach line in display_lines.iter() {
+    for 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);
@@ -305,7 +305,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
             s.push_char(' ');
         }
         let orig = fm.get_line(lines.lines[0] as int);
-        foreach pos in range(0u, left-skip) {
+        for pos in range(0u, left-skip) {
             let curChar = (orig[pos] as char);
             // Whenever a tab occurs on the previous line, we insert one on
             // the error-point-squiggly-line as well (instead of a space).
@@ -331,7 +331,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
 }
 
 fn print_macro_backtrace(cm: @codemap::CodeMap, sp: span) {
-    foreach ei in sp.expn_info.iter() {
+    for 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 9b2b37fe402..8d2d2432736 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 = ~[];
 
-    foreach expr in exprs.iter() {
+    for 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) => {
-                    foreach byte in s.byte_iter() {
+                    for 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 e47e3078636..edb5c634d56 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 = ~"";
-    foreach (i, e) in tts.iter().enumerate() {
+    for (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 77b5bf5bf2c..59b7da16c2b 100644
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@@ -83,7 +83,7 @@ fn decodable_substructure(cx: @ExtCtxt, span: span,
                         cx.expr_ident(span, substr.type_ident)
                     } else {
                         let mut fields = vec::with_capacity(n);
-                        foreach i in range(0, n) {
+                        for i in range(0, n) {
                             fields.push(getarg(fmt!("_field%u", i).to_managed(), i));
                         }
                         cx.expr_call_ident(span, substr.type_ident, fields)
@@ -109,7 +109,7 @@ fn decodable_substructure(cx: @ExtCtxt, span: span,
             let mut variants = ~[];
             let rvariant_arg = cx.ident_of("read_enum_variant_arg");
 
-            foreach (i, f) in fields.iter().enumerate() {
+            for (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)));
 
@@ -125,7 +125,7 @@ fn decodable_substructure(cx: @ExtCtxt, span: span,
                             cx.expr_ident(span, name)
                         } else {
                             let mut fields = vec::with_capacity(n);
-                            foreach i in range(0u, n) {
+                            for i in range(0u, n) {
                                 fields.push(getarg(i));
                             }
                             cx.expr_call_ident(span, name, fields)
diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs
index 0a2731f2f87..f16fea7bb06 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 = ~[];
-            foreach (i, f) in fields.iter().enumerate() {
+            for (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 = ~[];
-            foreach (i, f) in fields.iter().enumerate() {
+            for (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 8038b9878ef..f5eb57c94b7 100644
--- a/src/libsyntax/ext/deriving/generic.rs
+++ b/src/libsyntax/ext/deriving/generic.rs
@@ -283,7 +283,7 @@ impl<'self> TraitDef<'self> {
                   _mitem: @ast::MetaItem,
                   in_items: ~[@ast::item]) -> ~[@ast::item] {
         let mut result = ~[];
-        foreach item in in_items.iter() {
+        for item in in_items.iter() {
             result.push(*item);
             match item.node {
                 ast::item_struct(struct_def, ref generics) => {
@@ -321,11 +321,11 @@ impl<'self> TraitDef<'self> {
 
         let mut trait_generics = self.generics.to_generics(cx, span, type_ident, generics);
         // Copy the lifetimes
-        foreach l in generics.lifetimes.iter() {
+        for l in generics.lifetimes.iter() {
             trait_generics.lifetimes.push(*l)
         };
         // Create the type parameters.
-        foreach ty_param in generics.ty_params.iter() {
+        for 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(
@@ -485,7 +485,7 @@ impl<'self> MethodDef<'self> {
             None => respan(span, ast::sty_static),
         };
 
-        foreach (i, ty) in self.args.iter().enumerate() {
+        for (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));
@@ -579,7 +579,7 @@ impl<'self> MethodDef<'self> {
         let mut raw_fields = ~[]; // ~[[fields of self],
                                  // [fields of next Self arg], [etc]]
         let mut patterns = ~[];
-        foreach i in range(0u, self_args.len()) {
+        for i in range(0u, self_args.len()) {
             let (pat, ident_expr) = create_struct_pattern(cx, span,
                                                           type_ident, struct_def,
                                                           fmt!("__self_%u", i), ast::m_imm);
@@ -614,7 +614,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.
-        foreach (&arg_expr, &pat) in self_args.iter().zip(patterns.iter()) {
+        for (&arg_expr, &pat) in self_args.iter().zip(patterns.iter()) {
             body = cx.expr_match(span, arg_expr,
                                  ~[ cx.arm(span, ~[pat], body) ])
         }
@@ -738,10 +738,10 @@ impl<'self> MethodDef<'self> {
 
                     let mut enum_matching_fields = vec::from_elem(self_vec.len(), ~[]);
 
-                    foreach triple in matches_so_far.tail().iter() {
+                    for triple in matches_so_far.tail().iter() {
                         match triple {
                             &(_, _, ref other_fields) => {
-                                foreach (i, pair) in other_fields.iter().enumerate() {
+                                for (i, pair) in other_fields.iter().enumerate() {
                                     enum_matching_fields[i].push(pair.second());
                                 }
                             }
@@ -814,7 +814,7 @@ impl<'self> MethodDef<'self> {
                 }
             } else {
                 // create an arm matching on each variant
-                foreach (index, variant) in enum_def.variants.iter().enumerate() {
+                for (index, variant) in enum_def.variants.iter().enumerate() {
                     let (pattern, idents) = create_enum_variant_pattern(cx, span,
                                                                        variant,
                                                                        current_match_str,
@@ -877,7 +877,7 @@ fn summarise_struct(cx: @ExtCtxt, span: span,
                     struct_def: &struct_def) -> Either<uint, ~[ident]> {
     let mut named_idents = ~[];
     let mut unnamed_count = 0;
-    foreach field in struct_def.fields.iter() {
+    for field in struct_def.fields.iter() {
         match field.node.kind {
             ast::named_field(ident, _) => named_idents.push(ident),
             ast::unnamed_field => unnamed_count += 1,
@@ -931,7 +931,7 @@ fn create_struct_pattern(cx: @ExtCtxt,
     let mut ident_expr = ~[];
     let mut struct_type = Unknown;
 
-    foreach (i, struct_field) in struct_def.fields.iter().enumerate() {
+    for (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) => {
@@ -959,7 +959,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| {
-            foreach (&pat, &(id, _)) in subpats.iter().zip(ident_expr.iter()) {
+            for (&pat, &(id, _)) in subpats.iter().zip(ident_expr.iter()) {
                 // id is guaranteed to be Some
                 push(ast::field_pat { ident: id.get(), pat: pat })
             }
@@ -991,7 +991,7 @@ fn create_enum_variant_pattern(cx: @ExtCtxt,
 
             let mut paths = ~[];
             let mut ident_expr = ~[];
-            foreach i in range(0u, variant_args.len()) {
+            for i in range(0u, variant_args.len()) {
                 let path = cx.path_ident(span,
                                          cx.ident_of(fmt!("%s_%u", prefix, i)));
 
diff --git a/src/libsyntax/ext/deriving/iter_bytes.rs b/src/libsyntax/ext/deriving/iter_bytes.rs
index 215d5ca837d..b0f442ee638 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)`")
     }
 
-    foreach &(_, field, _) in fields.iter() {
+    for &(_, 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 c0f472ff456..3425352ff0c 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));
             };
 
-            foreach (i, &(name, e, _)) in fields.iter().enumerate() {
+            for (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 0ec367653c0..a6c5526b5a9 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -102,7 +102,7 @@ pub fn expand_expr(extsbox: @mut SyntaxEnv,
         }
 
         // Desugar expr_for_loop
-        // From: `foreach <src_pat> in <src_expr> <src_loop_block>`
+        // From: `for <src_pat> in <src_expr> <src_loop_block>`
         ast::expr_for_loop(src_pat, src_expr, ref src_loop_block) => {
             let src_pat = src_pat.clone();
             let src_expr = src_expr.clone();
@@ -543,7 +543,7 @@ impl Visitor<()> for NewNameFinderContext {
                     _ => ()
                 }
                 // visit optional subpattern of pat_ident:
-                foreach subpat in inner.iter() {
+                for subpat in inner.iter() {
                     self.visit_pat(*subpat, ())
                 }
             }
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index be8c0e2bd99..2dbf6887a21 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");
-            foreach f in flags.iter() {
+            for 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)
         }
-        foreach f in cnv.flags.iter() {
+        for 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")
         }
-        foreach f in c.flags.iter() {
+        for 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();
-    foreach (i, pc) in pieces.consume_iter().enumerate() {
+    for (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/quote.rs b/src/libsyntax/ext/quote.rs
index d5f032cd978..d218be5e476 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 = ~[];
-    foreach tt in tts.iter() {
+    for 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 982e605af22..5a1317034b2 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -137,7 +137,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;
-    foreach elt in ms.iter() {
+    for elt in ms.iter() {
         match elt.node {
           match_tok(_) => (),
           match_seq(_,_,_,_,hi) => {
@@ -194,7 +194,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, _, _, _, _), _} => {
-            foreach next_m in more_ms.iter() {
+            for next_m in more_ms.iter() {
                 n_rec(p_s, next_m, res, ret_val)
             };
           }
@@ -210,7 +210,7 @@ pub fn nameize(p_s: @mut ParseSess, ms: &[matcher], res: &[@named_match])
         }
     }
     let mut ret_val = HashMap::new();
-    foreach m in ms.iter() { n_rec(p_s, m, res, &mut ret_val) }
+    for m in ms.iter() { n_rec(p_s, m, res, &mut ret_val) }
     ret_val
 }
 
@@ -279,7 +279,7 @@ pub fn parse(
                         // most of the time.
 
                         // Only touch the binders we have actually bound
-                        foreach idx in range(ei.match_lo, ei.match_hi) {
+                        for idx in range(ei.match_lo, ei.match_hi) {
                             let sub = ei.matches[idx].clone();
                             new_pos.matches[idx]
                                 .push(@matched_seq(sub,
@@ -320,7 +320,7 @@ pub fn parse(
                         let mut new_ei = ei.clone();
                         new_ei.idx += 1u;
                         //we specifically matched zero repeats.
-                        foreach idx in range(match_idx_lo, match_idx_hi) {
+                        for idx in range(match_idx_lo, match_idx_hi) {
                             new_ei.matches[idx].push(@matched_seq(~[], sp));
                         }
 
@@ -355,7 +355,7 @@ pub fn parse(
         if tok == EOF {
             if eof_eis.len() == 1u {
                 let mut v = ~[];
-                foreach dv in eof_eis[0u].matches.mut_iter() {
+                for 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 304cf4756e1..10735dad32f 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;
 
-        foreach (i, lhs) in lhses.iter().enumerate() { // try each arm's matchers
+        for (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 9bda1189a8e..000f9c73797 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -379,7 +379,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 = ~[];
-    foreach stmt in b.stmts.iter() {
+    for stmt in b.stmts.iter() {
         match fld.fold_stmt(*stmt) {
             None => {}
             Some(stmt) => stmts.push(stmt)
diff --git a/src/libsyntax/oldvisit.rs b/src/libsyntax/oldvisit.rs
index 2de4aa474e5..d5296e60dd3 100644
--- a/src/libsyntax/oldvisit.rs
+++ b/src/libsyntax/oldvisit.rs
@@ -126,10 +126,10 @@ pub fn visit_mod<E:Clone>(m: &_mod,
                           _sp: span,
                           _id: NodeId,
                           (e, v): (E, vt<E>)) {
-    foreach vi in m.view_items.iter() {
+    for vi in m.view_items.iter() {
         (v.visit_view_item)(vi, (e.clone(), v));
     }
-    foreach i in m.items.iter() {
+    for 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) => {
-            foreach vi in nm.view_items.iter() {
+            for vi in nm.view_items.iter() {
                 (v.visit_view_item)(vi, (e.clone(), v));
             }
-            foreach ni in nm.items.iter() {
+            for 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));
-            foreach p in traits.iter() {
+            for p in traits.iter() {
                 visit_trait_ref(p, (e.clone(), v));
             }
             (v.visit_ty)(ty, (e.clone(), v));
-            foreach m in methods.iter() {
+            for 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));
-            foreach p in traits.iter() {
+            for p in traits.iter() {
                 visit_path(&p.path, (e.clone(), v));
             }
-            foreach m in methods.iter() {
+            for 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>)) {
-    foreach vr in enum_definition.variants.iter() {
+    for vr in enum_definition.variants.iter() {
         match vr.node.kind {
             tuple_variant_kind(ref variant_args) => {
-                foreach va in variant_args.iter() {
+                for 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
-        foreach ex in vr.node.disr_expr.iter() {
+        for 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) => {
-            foreach tt in ts.iter() {
+            for tt in ts.iter() {
                 (v.visit_ty)(tt, (e.clone(), v));
             }
         },
         ty_closure(ref f) => {
-            foreach a in f.decl.inputs.iter() {
+            for 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) => {
-            foreach a in f.decl.inputs.iter() {
+            for 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>)) {
-    foreach tp in p.types.iter() { (v.visit_ty)(tp, (e.clone(), v)); }
+    for 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));
-            foreach children in children.iter() {
-                foreach child in children.iter() {
+            for children in children.iter() {
+                for child in children.iter() {
                     (v.visit_pat)(*child, (e.clone(), v));
                 }
             }
         }
         pat_struct(ref path, ref fields, _) => {
             visit_path(path, (e.clone(), v));
-            foreach f in fields.iter() {
+            for f in fields.iter() {
                 (v.visit_pat)(f.pat, (e.clone(), v));
             }
         }
         pat_tup(ref elts) => {
-            foreach elt in elts.iter() {
+            for 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));
-            foreach subpat in inner.iter() {
+            for 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) => {
-            foreach elt in before.iter() {
+            for elt in before.iter() {
                 (v.visit_pat)(*elt, (e.clone(), v));
             }
-            foreach elt in slice.iter() {
+            for elt in slice.iter() {
                 (v.visit_pat)(*elt, (e.clone(), v));
             }
-            foreach tail in after.iter() {
+            for 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>)) {
-    foreach bound in bounds.iter() {
+    for 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>)) {
-    foreach tp in generics.ty_params.iter() {
+    for 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>)) {
-    foreach a in fd.inputs.iter() {
+    for a in fd.inputs.iter() {
         (v.visit_pat)(a.pat, (e.clone(), v));
         (v.visit_ty)(&a.ty, (e.clone(), v));
     }
@@ -399,7 +399,7 @@ pub fn visit_fn<E:Clone>(fk: &fn_kind,
 }
 
 pub fn visit_ty_method<E:Clone>(m: &TypeMethod, (e, v): (E, vt<E>)) {
-    foreach a in m.decl.inputs.iter() {
+    for a in m.decl.inputs.iter() {
         (v.visit_ty)(&a.ty, (e.clone(), v));
     }
     (v.visit_generics)(&m.generics, (e.clone(), v));
@@ -420,7 +420,7 @@ pub fn visit_struct_def<E:Clone>(
     _id: NodeId,
     (e, v): (E, vt<E>)
 ) {
-    foreach f in sd.fields.iter() {
+    for f in sd.fields.iter() {
         (v.visit_struct_field)(*f, (e.clone(), v));
     }
 }
@@ -430,10 +430,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>)) {
-    foreach vi in b.view_items.iter() {
+    for vi in b.view_items.iter() {
         (v.visit_view_item)(vi, (e.clone(), v));
     }
-    foreach s in b.stmts.iter() {
+    for s in b.stmts.iter() {
         (v.visit_stmt)(*s, (e.clone(), v));
     }
     visit_expr_opt(b.expr, (e, v));
@@ -460,7 +460,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>)) {
-    foreach ex in exprs.iter() { (v.visit_expr)(*ex, (e.clone(), v)); }
+    for ex in exprs.iter() { (v.visit_expr)(*ex, (e.clone(), v)); }
 }
 
 pub fn visit_mac<E>(_m: &mac, (_e, _v): (E, vt<E>)) {
@@ -477,13 +477,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));
-            foreach f in flds.iter() {
+            for f in flds.iter() {
                 (v.visit_expr)(f.expr, (e.clone(), v));
             }
             visit_expr_opt(base, (e.clone(), v));
         }
         expr_tup(ref elts) => {
-            foreach el in elts.iter() { (v.visit_expr)(*el, (e.clone(), v)) }
+            for el in elts.iter() { (v.visit_expr)(*el, (e.clone(), v)) }
         }
         expr_call(callee, ref args, _) => {
             visit_exprs(*args, (e.clone(), v));
@@ -491,7 +491,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));
-            foreach tp in tys.iter() {
+            for tp in tys.iter() {
                 (v.visit_ty)(tp, (e.clone(), v));
             }
             (v.visit_expr)(callee, (e.clone(), v));
@@ -524,7 +524,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));
-            foreach a in arms.iter() { (v.visit_arm)(a, (e.clone(), v)); }
+            for a in arms.iter() { (v.visit_arm)(a, (e.clone(), v)); }
         }
         expr_fn_block(ref decl, ref body) => {
             (v.visit_fn)(
@@ -547,7 +547,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));
-            foreach tp in tys.iter() {
+            for tp in tys.iter() {
                 (v.visit_ty)(tp, (e.clone(), v));
             }
         }
@@ -567,10 +567,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) => {
-            foreach &(_, input) in a.inputs.iter() {
+            for &(_, input) in a.inputs.iter() {
                 (v.visit_expr)(input, (e.clone(), v));
             }
-            foreach &(_, out) in a.outputs.iter() {
+            for &(_, out) in a.outputs.iter() {
                 (v.visit_expr)(out, (e.clone(), v));
             }
         }
@@ -579,7 +579,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>)) {
-    foreach p in a.pats.iter() { (v.visit_pat)(*p, (e.clone(), v)); }
+    for 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));
 }
diff --git a/src/libsyntax/parse/comments.rs b/src/libsyntax/parse/comments.rs
index c5454a2ca95..41379e6599c 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;
-        foreach line in lines.iter() {
-            foreach (j, c) in line.iter().enumerate() {
+        for line in lines.iter() {
+            for (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 3259d49fcd1..49deafeda40 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]) {
-        foreach expected_tok in expected.iter() {
+        for 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 ac3c50a53de..afa2e7a5e42 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1623,8 +1623,6 @@ impl Parser {
             hi = self.span.hi;
         } else if self.eat_keyword(keywords::If) {
             return self.parse_if_expr();
-        } else if self.eat_keyword(keywords::ForEach) {
-            return self.parse_for_expr();
         } else if self.eat_keyword(keywords::For) {
             return self.parse_for_expr();
         } else if self.eat_keyword(keywords::Do) {
@@ -3150,7 +3148,7 @@ impl Parser {
         } = self.parse_items_and_view_items(first_item_attrs,
                                             false, false);
 
-        foreach item in items.iter() {
+        for 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 +3753,7 @@ impl Parser {
             fields = ~[];
             while *self.token != token::RBRACE {
                 let r = self.parse_struct_decl_field();
-                foreach struct_field in r.iter() {
+                for struct_field in r.iter() {
                     fields.push(*struct_field)
                 }
             }
@@ -4038,7 +4036,7 @@ impl Parser {
             Some(i) => {
                 let stack = &self.sess.included_mod_stack;
                 let mut err = ~"circular modules: ";
-                foreach p in stack.slice(i, stack.len()).iter() {
+                for p in stack.slice(i, stack.len()).iter() {
                     err.push_str(p.to_str());
                     err.push_str(" -> ");
                 }
@@ -4252,7 +4250,7 @@ impl Parser {
         let mut fields: ~[@struct_field] = ~[];
         while *self.token != token::RBRACE {
             let r = self.parse_struct_decl_field();
-            foreach struct_field in r.iter() {
+            for struct_field in r.iter() {
                 fields.push(*struct_field);
             }
         }
@@ -4292,7 +4290,7 @@ impl Parser {
                     seq_sep_trailing_disallowed(token::COMMA),
                     |p| p.parse_ty(false)
                 );
-                foreach ty in arg_tys.consume_iter() {
+                for ty in arg_tys.consume_iter() {
                     args.push(ast::variant_arg {
                         ty: ty,
                         id: self.get_id(),
@@ -4401,7 +4399,7 @@ impl Parser {
                 self.bump();
                 let the_string = ident_to_str(&s);
                 let mut abis = AbiSet::empty();
-                foreach word in the_string.word_iter() {
+                for 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 706357320a5..39668e5c8b2 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -471,10 +471,9 @@ fn mk_fresh_ident_interner() -> @ident_interner {
         "use",                // 61
         "while",              // 62
         "in",                 // 63
-        "foreach",            // 64
 
-        "be",                 // 65
-        "pure",               // 66
+        "be",                 // 64
+        "pure",               // 65
     ];
 
     @ident_interner {
@@ -571,7 +570,6 @@ pub mod keywords {
         False,
         Fn,
         For,
-        ForEach,
         If,
         Impl,
         In,
@@ -615,7 +613,6 @@ pub mod keywords {
                 False => ident { name: 39, ctxt: 0 },
                 Fn => ident { name: 40, ctxt: 0 },
                 For => ident { name: 41, ctxt: 0 },
-                ForEach => ident { name: 64, ctxt: 0 },
                 If => ident { name: 42, ctxt: 0 },
                 Impl => ident { name: 43, ctxt: 0 },
                 In => ident { name: 63, ctxt: 0 },
@@ -628,7 +625,7 @@ pub mod keywords {
                 Once => ident { name: 50, ctxt: 0 },
                 Priv => ident { name: 51, ctxt: 0 },
                 Pub => ident { name: 52, ctxt: 0 },
-                Pure => ident { name: 66, ctxt: 0 },
+                Pure => ident { name: 65, ctxt: 0 },
                 Ref => ident { name: 53, ctxt: 0 },
                 Return => ident { name: 54, ctxt: 0 },
                 Static => ident { name: 27, ctxt: 0 },
@@ -641,7 +638,7 @@ pub mod keywords {
                 Unsafe => ident { name: 60, ctxt: 0 },
                 Use => ident { name: 61, ctxt: 0 },
                 While => ident { name: 62, ctxt: 0 },
-                Be => ident { name: 65, ctxt: 0 },
+                Be => ident { name: 64, ctxt: 0 },
             }
         }
     }
@@ -657,7 +654,7 @@ pub fn is_keyword(kw: keywords::Keyword, tok: &Token) -> bool {
 pub fn is_any_keyword(tok: &Token) -> bool {
     match *tok {
         token::IDENT(sid, false) => match sid.name {
-            8 | 27 | 32 .. 66 => true,
+            8 | 27 | 32 .. 65 => true,
             _ => false,
         },
         _ => false
@@ -667,7 +664,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 .. 64 => true,
+            8 | 27 | 32 .. 63 => true,
             _ => false,
         },
         _ => false,
@@ -677,7 +674,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 {
-            65 .. 66 => true,
+            64 .. 65 => true,
             _ => false,
         },
         _ => false,
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 7d885837a60..c3fcacdf7b0 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -320,7 +320,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;
-    foreach elt in elts.iter() {
+    for elt in elts.iter() {
         if first { first = false; } else { word_space(s, ","); }
         op(s, elt);
     }
@@ -333,7 +333,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;
-    foreach elt in elts.iter() {
+    for elt in elts.iter() {
         maybe_print_comment(s, get_span(elt).hi);
         op(s, elt);
         i += 1u;
@@ -353,23 +353,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);
-    foreach vitem in _mod.view_items.iter() {
+    for vitem in _mod.view_items.iter() {
         print_view_item(s, vitem);
     }
-    foreach item in _mod.items.iter() { print_item(s, *item); }
+    for 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);
-    foreach vitem in nmod.view_items.iter() {
+    for vitem in nmod.view_items.iter() {
         print_view_item(s, vitem);
     }
-    foreach item in nmod.items.iter() { print_foreign_item(s, *item); }
+    for item in nmod.items.iter() { print_foreign_item(s, *item); }
 }
 
 pub fn print_opt_lifetime(s: @ps, lifetime: &Option<ast::Lifetime>) {
-    foreach l in lifetime.iter() {
+    for l in lifetime.iter() {
         print_lifetime(s, l);
         nbsp(s);
     }
@@ -589,7 +589,7 @@ pub fn print_item(s: @ps, item: &ast::item) {
             word(s.s, ";");
         } else {
             bopen(s);
-            foreach meth in methods.iter() {
+            for meth in methods.iter() {
                print_method(s, *meth);
             }
             bclose(s, item.span);
@@ -601,7 +601,7 @@ pub fn print_item(s: @ps, item: &ast::item) {
         print_generics(s, generics);
         if traits.len() != 0u {
             word(s.s, ":");
-            foreach (i, trait_) in traits.iter().enumerate() {
+            for (i, trait_) in traits.iter().enumerate() {
                 nbsp(s);
                 if i != 0 {
                     word_space(s, "+");
@@ -611,7 +611,7 @@ pub fn print_item(s: @ps, item: &ast::item) {
         }
         word(s.s, " ");
         bopen(s);
-        foreach meth in methods.iter() {
+        for meth in methods.iter() {
             print_trait_method(s, meth);
         }
         bclose(s, item.span);
@@ -650,7 +650,7 @@ pub fn print_variants(s: @ps,
                       variants: &[ast::variant],
                       span: codemap::span) {
     bopen(s);
-    foreach v in variants.iter() {
+    for v in variants.iter() {
         space_if_not_bol(s);
         maybe_print_comment(s, v.span.lo);
         print_outer_attributes(s, v.node.attrs);
@@ -715,7 +715,7 @@ pub fn print_struct(s: @ps,
         bopen(s);
         hardbreak_if_not_bol(s);
 
-        foreach field in struct_def.fields.iter() {
+        for field in struct_def.fields.iter() {
             match field.node.kind {
                 ast::unnamed_field => fail!("unexpected unnamed field"),
                 ast::named_field(ident, visibility) => {
@@ -750,7 +750,7 @@ pub fn print_tt(s: @ps, tt: &ast::token_tree) {
       }
       ast::tt_seq(_, ref tts, ref sep, zerok) => {
         word(s.s, "$(");
-        foreach tt_elt in (*tts).iter() { print_tt(s, tt_elt); }
+        for 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)),
@@ -767,7 +767,7 @@ pub fn print_tt(s: @ps, tt: &ast::token_tree) {
 
 pub fn print_tts(s: @ps, tts: & &[ast::token_tree]) {
     ibox(s, 0);
-    foreach (i, tt) in tts.iter().enumerate() {
+    for (i, tt) in tts.iter().enumerate() {
         if i != 0 {
             space(s.s);
         }
@@ -844,7 +844,7 @@ pub fn print_method(s: @ps, meth: &ast::method) {
 
 pub fn print_outer_attributes(s: @ps, attrs: &[ast::Attribute]) {
     let mut count = 0;
-    foreach attr in attrs.iter() {
+    for attr in attrs.iter() {
         match attr.node.style {
           ast::AttrOuter => { print_attribute(s, attr); count += 1; }
           _ => {/* fallthrough */ }
@@ -855,7 +855,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;
-    foreach attr in attrs.iter() {
+    for attr in attrs.iter() {
         match attr.node.style {
           ast::AttrInner => {
             print_attribute(s, attr);
@@ -960,8 +960,8 @@ pub fn print_possibly_embedded_block_(s: @ps,
 
     print_inner_attributes(s, attrs);
 
-    foreach vi in blk.view_items.iter() { print_view_item(s, vi); }
-    foreach st in blk.stmts.iter() {
+    for vi in blk.view_items.iter() { print_view_item(s, vi); }
+    for st in blk.stmts.iter() {
         print_stmt(s, *st);
     }
     match blk.expr {
@@ -1228,7 +1228,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
         print_block(s, blk);
       }
       ast::expr_for_loop(pat, iter, ref blk) => {
-        head(s, "foreach");
+        head(s, "for");
         print_pat(s, pat);
         space(s.s);
         word_space(s, "in");
@@ -1237,7 +1237,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
         print_block(s, blk);
       }
       ast::expr_loop(ref blk, opt_ident) => {
-        foreach ident in opt_ident.iter() {
+        for ident in opt_ident.iter() {
             word(s.s, "'");
             print_ident(s, *ident);
             word_space(s, ":");
@@ -1254,12 +1254,12 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
         space(s.s);
         bopen(s);
         let len = arms.len();
-        foreach (i, arm) in arms.iter().enumerate() {
+        for (i, arm) in arms.iter().enumerate() {
             space(s.s);
             cbox(s, indent_unit);
             ibox(s, 0u);
             let mut first = true;
-            foreach p in arm.pats.iter() {
+            for p in arm.pats.iter() {
                 if first {
                     first = false;
                 } else { space(s.s); word_space(s, "|"); }
@@ -1385,7 +1385,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
       ast::expr_break(opt_ident) => {
         word(s.s, "break");
         space(s.s);
-        foreach ident in opt_ident.iter() {
+        for ident in opt_ident.iter() {
             word(s.s, "'");
             print_ident(s, *ident);
             space(s.s);
@@ -1394,7 +1394,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
       ast::expr_again(opt_ident) => {
         word(s.s, "loop");
         space(s.s);
-        foreach ident in opt_ident.iter() {
+        for ident in opt_ident.iter() {
             word(s.s, "'");
             print_ident(s, *ident);
             space(s.s)
@@ -1425,7 +1425,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
         popen(s);
         print_string(s, a.asm);
         word_space(s, ":");
-        foreach &(co, o) in a.outputs.iter() {
+        for &(co, o) in a.outputs.iter() {
             print_string(s, co);
             popen(s);
             print_expr(s, o);
@@ -1433,7 +1433,7 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
             word_space(s, ",");
         }
         word_space(s, ":");
-        foreach &(co, o) in a.inputs.iter() {
+        for &(co, o) in a.inputs.iter() {
             print_string(s, co);
             popen(s);
             print_expr(s, o);
@@ -1512,7 +1512,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;
-    foreach id in path.idents.iter() {
+    for id in path.idents.iter() {
         if first { first = false; } else { word(s.s, "::"); }
         print_ident(s, *id);
     }
@@ -1525,7 +1525,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, "<");
 
-            foreach r in path.rp.iter() {
+            for r in path.rp.iter() {
                 print_lifetime(s, r);
                 if !path.types.is_empty() {
                     word_space(s, ",");
@@ -1639,7 +1639,7 @@ pub fn print_pat(s: @ps, pat: &ast::pat) {
         do commasep(s, inconsistent, *before) |s, &p| {
             print_pat(s, p);
         }
-        foreach &p in slice.iter() {
+        for &p in slice.iter() {
             if !before.is_empty() { word_space(s, ","); }
             word(s.s, "..");
             print_pat(s, p);
@@ -1699,11 +1699,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;
-    foreach explicit_self in opt_explicit_self.iter() {
+    for explicit_self in opt_explicit_self.iter() {
         first = !print_explicit_self(s, *explicit_self);
     }
 
-    foreach arg in decl.inputs.iter() {
+    for arg in decl.inputs.iter() {
         if first { first = false; } else { word_space(s, ","); }
         print_arg(s, arg);
     }
@@ -1750,7 +1750,7 @@ pub fn print_bounds(s: @ps, bounds: &OptVec<ast::TyParamBound>,
     if !bounds.is_empty() {
         word(s.s, ":");
         let mut first = true;
-        foreach bound in bounds.iter() {
+        for bound in bounds.iter() {
             nbsp(s);
             if first {
                 first = false;
@@ -1790,7 +1790,7 @@ pub fn print_generics(s: @ps, generics: &ast::Generics) {
         }
 
         let mut ints = ~[];
-        foreach i in range(0u, total) {
+        for i in range(0u, total) {
             ints.push(i);
         }
 
@@ -1949,10 +1949,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;
-    foreach explicit_self in opt_explicit_self.iter() {
+    for explicit_self in opt_explicit_self.iter() {
         first = !print_explicit_self(s, *explicit_self);
     }
-    foreach arg in decl.inputs.iter() {
+    for arg in decl.inputs.iter() {
         if first { first = false; } else { word_space(s, ","); }
         print_arg(s, arg);
     }
@@ -2108,7 +2108,7 @@ pub fn print_comment(s: @ps, cmnt: &comments::cmnt) {
       }
       comments::isolated => {
         pprust::hardbreak_if_not_bol(s);
-        foreach line in cmnt.lines.iter() {
+        for 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); }
@@ -2122,7 +2122,7 @@ pub fn print_comment(s: @ps, cmnt: &comments::cmnt) {
             hardbreak(s.s);
         } else {
             ibox(s, 0u);
-            foreach line in cmnt.lines.iter() {
+            for 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 b9c8c3f4e4c..46676ce1093 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();
-        foreach v in init.iter() {
+        for 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();
-        foreach &v in init.iter() { rv.intern(v); }
+        for &v in init.iter() { rv.intern(v); }
         rv
     }
 
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 6f228a9a43b..15864fab258 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -93,10 +93,10 @@ pub fn visit_crate<E:Clone>(visitor: @Visitor<E>, crate: &Crate, env: E) {
 }
 
 pub fn visit_mod<E:Clone>(visitor: @Visitor<E>, module: &_mod, env: E) {
-    foreach view_item in module.view_items.iter() {
+    for view_item in module.view_items.iter() {
         visitor.visit_view_item(view_item, env.clone())
     }
-    foreach item in module.items.iter() {
+    for item in module.items.iter() {
         visitor.visit_item(*item, env.clone())
     }
 }
@@ -138,10 +138,10 @@ pub fn visit_item<E:Clone>(visitor: @Visitor<E>, item: &item, env: E) {
             visitor.visit_mod(module, item.span, item.id, env)
         }
         item_foreign_mod(ref foreign_module) => {
-            foreach view_item in foreign_module.view_items.iter() {
+            for view_item in foreign_module.view_items.iter() {
                 visitor.visit_view_item(view_item, env.clone())
             }
-            foreach foreign_item in foreign_module.items.iter() {
+            for foreign_item in foreign_module.items.iter() {
                 visitor.visit_foreign_item(*foreign_item, env.clone())
             }
         }
@@ -158,11 +158,11 @@ pub fn visit_item<E:Clone>(visitor: @Visitor<E>, item: &item, env: E) {
                   ref typ,
                   ref methods) => {
             visitor.visit_generics(type_parameters, env.clone());
-            foreach trait_reference in trait_references.iter() {
+            for trait_reference in trait_references.iter() {
                 visit_trait_ref(visitor, trait_reference, env.clone())
             }
             visitor.visit_ty(typ, env.clone());
-            foreach method in methods.iter() {
+            for method in methods.iter() {
                 visit_method_helper(visitor, *method, env.clone())
             }
         }
@@ -176,10 +176,10 @@ pub fn visit_item<E:Clone>(visitor: @Visitor<E>, item: &item, env: E) {
         }
         item_trait(ref generics, ref trait_paths, ref methods) => {
             visitor.visit_generics(generics, env.clone());
-            foreach trait_path in trait_paths.iter() {
+            for trait_path in trait_paths.iter() {
                 visit_path(visitor, &trait_path.path, env.clone())
             }
-            foreach method in methods.iter() {
+            for method in methods.iter() {
                 visitor.visit_trait_method(method, env.clone())
             }
         }
@@ -191,10 +191,10 @@ pub fn visit_enum_def<E:Clone>(visitor: @Visitor<E>,
                                enum_definition: &ast::enum_def,
                                generics: &Generics,
                                env: E) {
-    foreach variant in enum_definition.variants.iter() {
+    for variant in enum_definition.variants.iter() {
         match variant.node.kind {
             tuple_variant_kind(ref variant_arguments) => {
-                foreach variant_argument in variant_arguments.iter() {
+                for variant_argument in variant_arguments.iter() {
                     visitor.visit_ty(&variant_argument.ty, env.clone())
                 }
             }
@@ -221,28 +221,28 @@ pub fn visit_ty<E:Clone>(visitor: @Visitor<E>, typ: &Ty, env: E) {
             visitor.visit_ty(mutable_type.ty, env)
         }
         ty_tup(ref tuple_element_types) => {
-            foreach tuple_element_type in tuple_element_types.iter() {
+            for tuple_element_type in tuple_element_types.iter() {
                 visitor.visit_ty(tuple_element_type, env.clone())
             }
         }
         ty_closure(ref function_declaration) => {
-             foreach argument in function_declaration.decl.inputs.iter() {
+             for argument in function_declaration.decl.inputs.iter() {
                 visitor.visit_ty(&argument.ty, env.clone())
              }
              visitor.visit_ty(&function_declaration.decl.output, env.clone());
-             foreach bounds in function_declaration.bounds.iter() {
+             for bounds in function_declaration.bounds.iter() {
                 visit_ty_param_bounds(visitor, bounds, env.clone())
              }
         }
         ty_bare_fn(ref function_declaration) => {
-            foreach argument in function_declaration.decl.inputs.iter() {
+            for argument in function_declaration.decl.inputs.iter() {
                 visitor.visit_ty(&argument.ty, env.clone())
             }
             visitor.visit_ty(&function_declaration.decl.output, env.clone())
         }
         ty_path(ref path, ref bounds, _) => {
             visit_path(visitor, path, env.clone());
-            foreach bounds in bounds.iter() {
+            for bounds in bounds.iter() {
                 visit_ty_param_bounds(visitor, bounds, env.clone())
             }
         }
@@ -255,7 +255,7 @@ pub fn visit_ty<E:Clone>(visitor: @Visitor<E>, typ: &Ty, env: E) {
 }
 
 pub fn visit_path<E:Clone>(visitor: @Visitor<E>, path: &Path, env: E) {
-    foreach typ in path.types.iter() {
+    for typ in path.types.iter() {
         visitor.visit_ty(typ, env.clone())
     }
 }
@@ -264,20 +264,20 @@ pub fn visit_pat<E:Clone>(visitor: @Visitor<E>, pattern: &pat, env: E) {
     match pattern.node {
         pat_enum(ref path, ref children) => {
             visit_path(visitor, path, env.clone());
-            foreach children in children.iter() {
-                foreach child in children.iter() {
+            for children in children.iter() {
+                for child in children.iter() {
                     visitor.visit_pat(*child, env.clone())
                 }
             }
         }
         pat_struct(ref path, ref fields, _) => {
             visit_path(visitor, path, env.clone());
-            foreach field in fields.iter() {
+            for field in fields.iter() {
                 visitor.visit_pat(field.pat, env.clone())
             }
         }
         pat_tup(ref tuple_elements) => {
-            foreach tuple_element in tuple_elements.iter() {
+            for tuple_element in tuple_elements.iter() {
                 visitor.visit_pat(*tuple_element, env.clone())
             }
         }
@@ -300,13 +300,13 @@ pub fn visit_pat<E:Clone>(visitor: @Visitor<E>, pattern: &pat, env: E) {
         }
         pat_wild => (),
         pat_vec(ref prepattern, ref slice_pattern, ref postpatterns) => {
-            foreach prepattern in prepattern.iter() {
+            for prepattern in prepattern.iter() {
                 visitor.visit_pat(*prepattern, env.clone())
             }
-            foreach slice_pattern in slice_pattern.iter() {
+            for slice_pattern in slice_pattern.iter() {
                 visitor.visit_pat(*slice_pattern, env.clone())
             }
-            foreach postpattern in postpatterns.iter() {
+            for postpattern in postpatterns.iter() {
                 visitor.visit_pat(*postpattern, env.clone())
             }
         }
@@ -328,7 +328,7 @@ pub fn visit_foreign_item<E:Clone>(visitor: @Visitor<E>,
 pub fn visit_ty_param_bounds<E:Clone>(visitor: @Visitor<E>,
                                       bounds: &OptVec<TyParamBound>,
                                       env: E) {
-    foreach bound in bounds.iter() {
+    for bound in bounds.iter() {
         match *bound {
             TraitTyParamBound(ref typ) => {
                 visit_trait_ref(visitor, typ, env.clone())
@@ -341,7 +341,7 @@ pub fn visit_ty_param_bounds<E:Clone>(visitor: @Visitor<E>,
 pub fn visit_generics<E:Clone>(visitor: @Visitor<E>,
                                generics: &Generics,
                                env: E) {
-    foreach type_parameter in generics.ty_params.iter() {
+    for type_parameter in generics.ty_params.iter() {
         visit_ty_param_bounds(visitor, &type_parameter.bounds, env.clone())
     }
 }
@@ -349,7 +349,7 @@ pub fn visit_generics<E:Clone>(visitor: @Visitor<E>,
 pub fn visit_fn_decl<E:Clone>(visitor: @Visitor<E>,
                               function_declaration: &fn_decl,
                               env: E) {
-    foreach argument in function_declaration.inputs.iter() {
+    for argument in function_declaration.inputs.iter() {
         visitor.visit_pat(argument.pat, env.clone());
         visitor.visit_ty(&argument.ty, env.clone())
     }
@@ -387,7 +387,7 @@ pub fn visit_fn<E:Clone>(visitor: @Visitor<E>,
 pub fn visit_ty_method<E:Clone>(visitor: @Visitor<E>,
                                 method_type: &TypeMethod,
                                 env: E) {
-    foreach argument_type in method_type.decl.inputs.iter() {
+    for argument_type in method_type.decl.inputs.iter() {
         visitor.visit_ty(&argument_type.ty, env.clone())
     }
     visitor.visit_generics(&method_type.generics, env.clone());
@@ -411,7 +411,7 @@ pub fn visit_struct_def<E:Clone>(visitor: @Visitor<E>,
                                  _: &Generics,
                                  _: NodeId,
                                  env: E) {
-    foreach field in struct_definition.fields.iter() {
+    for field in struct_definition.fields.iter() {
         visitor.visit_struct_field(*field, env.clone())
     }
 }
@@ -423,10 +423,10 @@ pub fn visit_struct_field<E:Clone>(visitor: @Visitor<E>,
 }
 
 pub fn visit_block<E:Clone>(visitor: @Visitor<E>, block: &Block, env: E) {
-    foreach view_item in block.view_items.iter() {
+    for view_item in block.view_items.iter() {
         visitor.visit_view_item(view_item, env.clone())
     }
-    foreach statement in block.stmts.iter() {
+    for statement in block.stmts.iter() {
         visitor.visit_stmt(*statement, env.clone())
     }
     visit_expr_opt(visitor, block.expr, env)
@@ -461,7 +461,7 @@ pub fn visit_expr_opt<E>(visitor: @Visitor<E>,
 pub fn visit_exprs<E:Clone>(visitor: @Visitor<E>,
                             expressions: &[@expr],
                             env: E) {
-    foreach expression in expressions.iter() {
+    for expression in expressions.iter() {
         visitor.visit_expr(*expression, env.clone())
     }
 }
@@ -484,25 +484,25 @@ pub fn visit_expr<E:Clone>(visitor: @Visitor<E>, expression: @expr, env: E) {
         }
         expr_struct(ref path, ref fields, optional_base) => {
             visit_path(visitor, path, env.clone());
-            foreach field in fields.iter() {
+            for field in fields.iter() {
                 visitor.visit_expr(field.expr, env.clone())
             }
             visit_expr_opt(visitor, optional_base, env.clone())
         }
         expr_tup(ref subexpressions) => {
-            foreach subexpression in subexpressions.iter() {
+            for subexpression in subexpressions.iter() {
                 visitor.visit_expr(*subexpression, env.clone())
             }
         }
         expr_call(callee_expression, ref arguments, _) => {
-            foreach argument in arguments.iter() {
+            for argument in arguments.iter() {
                 visitor.visit_expr(*argument, env.clone())
             }
             visitor.visit_expr(callee_expression, env.clone())
         }
         expr_method_call(_, callee, _, ref types, ref arguments, _) => {
             visit_exprs(visitor, *arguments, env.clone());
-            foreach typ in types.iter() {
+            for typ in types.iter() {
                 visitor.visit_ty(typ, env.clone())
             }
             visitor.visit_expr(callee, env.clone())
@@ -539,7 +539,7 @@ pub fn visit_expr<E:Clone>(visitor: @Visitor<E>, expression: @expr, env: E) {
         expr_loop(ref block, _) => visitor.visit_block(block, env.clone()),
         expr_match(subexpression, ref arms) => {
             visitor.visit_expr(subexpression, env.clone());
-            foreach arm in arms.iter() {
+            for arm in arms.iter() {
                 visitor.visit_arm(arm, env.clone())
             }
         }
@@ -562,7 +562,7 @@ pub fn visit_expr<E:Clone>(visitor: @Visitor<E>, expression: @expr, env: E) {
         }
         expr_field(subexpression, _, ref types) => {
             visitor.visit_expr(subexpression, env.clone());
-            foreach typ in types.iter() {
+            for typ in types.iter() {
                 visitor.visit_ty(typ, env.clone())
             }
         }
@@ -584,10 +584,10 @@ pub fn visit_expr<E:Clone>(visitor: @Visitor<E>, expression: @expr, env: E) {
             visitor.visit_expr(subexpression, env.clone())
         }
         expr_inline_asm(ref assembler) => {
-            foreach &(_, input) in assembler.inputs.iter() {
+            for &(_, input) in assembler.inputs.iter() {
                 visitor.visit_expr(input, env.clone())
             }
-            foreach &(_, output) in assembler.outputs.iter() {
+            for &(_, output) in assembler.outputs.iter() {
                 visitor.visit_expr(output, env.clone())
             }
         }
@@ -597,7 +597,7 @@ pub fn visit_expr<E:Clone>(visitor: @Visitor<E>, expression: @expr, env: E) {
 }
 
 pub fn visit_arm<E:Clone>(visitor: @Visitor<E>, arm: &arm, env: E) {
-    foreach pattern in arm.pats.iter() {
+    for pattern in arm.pats.iter() {
         visitor.visit_pat(*pattern, env.clone())
     }
     visit_expr_opt(visitor, arm.guard, env.clone());