remove obsolete `foreach` keyword

this has been replaced by `for`

12 files changed, 37 insertions, 37 deletions

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