---

yaml
---
r: 5900
b: refs/heads/master
c: 0ce40f6
h: refs/heads/master
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 050170d2af94ea81b9b964901e4de7eb79583332
+refs/heads/master: 0ce40f60e79598c198851154cc978375ed5e7747

trunk/src/comp/metadata/tydecode.rs

@@ -251,11 +251,6 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
         ret ty::mk_fn(st.tcx, ast::proto_bare, func.args, func.ty, func.cf,
                       func.cs);
       }
-      'W' {
-        let func = parse_ty_fn(st, sd);
-        ret ty::mk_fn(st.tcx, ast::proto_iter, func.args, func.ty, func.cf,
-                      func.cs);
-      }
       'B' {
         let func = parse_ty_fn(st, sd);
         ret ty::mk_fn(st.tcx, ast::proto_block, func.args, func.ty, func.cf,
@@ -281,7 +276,6 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
         while peek(st) as char != ']' {
             let proto;
             alt next(st) as char {
-              'W' { proto = ast::proto_iter; }
               'f' { proto = ast::proto_bare; }
             }
             let name = "";

trunk/src/comp/metadata/tyencode.rs

@@ -194,7 +194,6 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
 }
 fn enc_proto(w: io::writer, proto: proto) {
     alt proto {
-      proto_iter. { w.write_char('W'); }
       proto_shared(_) { w.write_char('F'); }
       proto_block. { w.write_char('B'); }
       proto_bare. { w.write_char('f'); }

trunk/src/comp/middle/alias.rs

@@ -98,23 +98,6 @@ fn visit_expr(cx: @ctx, ex: @ast::expr, sc: scope, v: vt<scope>) {
         handled = false;
       }
       ast::expr_alt(input, arms) { check_alt(*cx, input, arms, sc, v); }
-      ast::expr_put(val) {
-        alt val {
-          some(ex) {
-            let root = expr_root(*cx, ex, false);
-            if !is_none(root.mut) {
-                cx.tcx.sess.span_err(ex.span,
-                                     "result of put must be" +
-                                         " immutably rooted");
-            }
-            visit_expr(cx, ex, sc, v);
-          }
-          _ { }
-        }
-      }
-      ast::expr_for_each(decl, call, blk) {
-        check_for_each(*cx, decl, call, blk, sc, v);
-      }
       ast::expr_for(decl, seq, blk) { check_for(*cx, decl, seq, blk, sc, v); }
       ast::expr_path(pt) {
         check_var(*cx, ex, pt, ex.id, false, sc);
@@ -424,21 +407,6 @@ fn check_alt(cx: ctx, input: @ast::expr, arms: [ast::arm], sc: scope,
     }
 }
 
-fn check_for_each(cx: ctx, local: @ast::local, call: @ast::expr,
-                  blk: ast::blk, sc: scope, v: vt<scope>) {
-    v.visit_expr(call, sc, v);
-    alt call.node {
-      ast::expr_call(f, args) {
-        let new_bs = sc.bs + check_call(cx, f, args);
-        for proot in pattern_roots(cx.tcx, none, local.node.pat) {
-            new_bs += [mk_binding(cx, proot.id, proot.span, none,
-                                  unsafe_set(proot.mut))];
-        }
-        visit::visit_block(blk, {bs: new_bs with sc}, v);
-      }
-    }
-}
-
 fn check_for(cx: ctx, local: @ast::local, seq: @ast::expr, blk: ast::blk,
              sc: scope, v: vt<scope>) {
     v.visit_expr(seq, sc, v);

trunk/src/comp/middle/freevars.rs

@@ -41,11 +41,6 @@ fn collect_freevars(def_map: resolve::def_map, walker: fn@(visit::vt<int>)) ->
                     visit::visit_expr(expr, depth + 1, v);
                 }
               }
-              ast::expr_for_each(dcl, x, b) {
-                v.visit_local(dcl, depth, v);
-                v.visit_expr(x, depth, v);
-                v.visit_block(b, depth + 1, v);
-              }
               ast::expr_path(path) {
                 let def = def_map.get(expr.id), i = 0;
                 while i < depth {
@@ -91,21 +86,9 @@ fn annotate_freevars(def_map: resolve::def_map, crate: @ast::crate) ->
             let vars = collect_freevars(def_map, start_walk);
             freevars.insert(nid, vars);
         };
-    let walk_expr =
-        lambda (expr: @ast::expr) {
-            alt expr.node {
-              ast::expr_for_each(local, _, body) {
-                let start_walk =
-                    lambda (v: visit::vt<int>) { v.visit_block(body, 1, v); };
-                let vars = collect_freevars(def_map, start_walk);
-                freevars.insert(body.node.id, vars);
-              }
-              _ { }
-            }
-        };
 
     let visitor =
-        visit::mk_simple_visitor(@{visit_fn: walk_fn, visit_expr: walk_expr
+        visit::mk_simple_visitor(@{visit_fn: walk_fn
                                       with *visit::default_simple_visitor()});
     visit::visit_crate(*crate, (), visitor);
 

trunk/src/comp/middle/resolve.rs

@@ -37,7 +37,7 @@ tag scope {
     scope_item(@ast::item);
     scope_fn(ast::fn_decl, ast::proto, [ast::ty_param]);
     scope_native_item(@ast::native_item);
-    scope_loop(@ast::local, bool); // there's only 1 decl per loop.
+    scope_loop(@ast::local); // there's only 1 decl per loop.
 
     scope_block(ast::blk, @mutable uint, @mutable uint);
     scope_arm(ast::arm);
@@ -381,9 +381,8 @@ fn visit_arm_with_scope(a: ast::arm, sc: scopes, v: vt<scopes>) {
 
 fn visit_expr_with_scope(x: @ast::expr, sc: scopes, v: vt<scopes>) {
     alt x.node {
-      ast::expr_for(decl, coll, blk) | ast::expr_for_each(decl, coll, blk) {
-        let f_e = alt x.node { expr_for_each(_, _, _) { true } _ { false } };
-        let new_sc = cons(scope_loop(decl, f_e), @sc);
+      ast::expr_for(decl, coll, blk) {
+        let new_sc = cons(scope_loop(decl), @sc);
         v.visit_expr(coll, sc, v);
         v.visit_local(decl, new_sc, v);
         v.visit_block(blk, new_sc, v);
@@ -589,7 +588,6 @@ fn lookup_in_scope_strict(e: env, sc: scopes, sp: span, name: ident,
 
 fn scope_is_fn(sc: scope) -> bool {
     ret alt sc {
-          scope_fn(_, ast::proto_iter., _) |
           scope_fn(_, ast::proto_bare., _) |
           scope_native_item(_) {
             true
@@ -600,7 +598,7 @@ fn scope_is_fn(sc: scope) -> bool {
 
 fn scope_closes(sc: scope) -> option::t<bool> {
     alt sc {
-      scope_fn(_, ast::proto_block., _) | scope_loop(_, true) { some(true) }
+      scope_fn(_, ast::proto_block., _) { some(true) }
       scope_fn(_, ast::proto_shared(_), _) { some(false) }
       _ { none }
     }
@@ -662,7 +660,7 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace)
           scope_fn(decl, _, ty_params) {
             ret lookup_in_fn(name, decl, ty_params, ns);
           }
-          scope_loop(local, _) {
+          scope_loop(local) {
             if ns == ns_value {
                 alt lookup_in_pat(name, local.node.pat) {
                   some(did) { ret some(ast::def_binding(did)); }