Move ast_util::pat_bindings over to new iter system.

Issue #1056

Author: marijnh

src/comp/middle/ast_map.rs

@@ -46,17 +46,17 @@ fn map_fn(cx: ctx, f: _fn, _tp: [ty_param], _sp: codemap::span,
 }
 
 fn map_local(cx: ctx, loc: @local) {
-    for each p in ast_util::pat_bindings(loc.node.pat) {
+    ast_util::pat_bindings(loc.node.pat) {|p|
         cx.map.insert(p.id, node_local(cx.local_id));
         cx.local_id += 1u;
-    }
+    };
 }
 
 fn map_arm(cx: ctx, arm: arm) {
-    for each p in ast_util::pat_bindings(arm.pats[0]) {
+    ast_util::pat_bindings(arm.pats[0]) {|p|
         cx.map.insert(p.id, node_local(cx.local_id));
         cx.local_id += 1u;
-    }
+    };
 }
 
 fn map_item(cx: ctx, i: @item) {

src/comp/middle/resolve.rs

@@ -744,10 +744,10 @@ fn lookup_in_ty_params(name: ident, ty_params: [ast::ty_param]) ->
 
 fn lookup_in_pat(name: ident, pat: @ast::pat) -> option::t<def_id> {
     let found = none;
-    for each bound in ast_util::pat_bindings(pat) {
+    ast_util::pat_bindings(pat) {|bound|
         let p_name = alt bound.node { ast::pat_bind(n) { n } };
         if str::eq(p_name, name) { found = some(local_def(bound.id)); }
-    }
+    };
     ret found;
 }
 
@@ -1269,10 +1269,10 @@ fn check_item(e: @env, i: @ast::item, &&x: (), v: vt<()>) {
 }
 
 fn check_pat(ch: checker, p: @ast::pat) {
-    for each p in ast_util::pat_bindings(p) {
+    ast_util::pat_bindings(p) {|p|
         let ident = alt p.node { pat_bind(n) { n } };
         add_name(ch, p.span, ident);
-    }
+    };
 }
 
 fn check_arm(e: @env, a: ast::arm, &&x: (), v: vt<()>) {
@@ -1317,11 +1317,11 @@ fn check_block(e: @env, b: ast::blk, &&x: (), v: vt<()>) {
               ast::decl_local(locs) {
                 let local_values = checker(*e, "value");
                 for (_, loc) in locs {
-                    for each p in ast_util::pat_bindings(loc.node.pat) {
+                    ast_util::pat_bindings(loc.node.pat) {|p|
                         let ident = alt p.node { pat_bind(n) { n } };
                         add_name(local_values, p.span, ident);
                         check_name(values, p.span, ident);
-                    }
+                    };
                 }
               }
               ast::decl_item(it) {

src/comp/middle/tstate/auxiliary.rs

@@ -1055,10 +1055,10 @@ type binding = {lhs: [inst], rhs: option::t<initializer>};
 
 fn local_to_bindings(loc: @local) -> binding {
     let lhs = [];
-    for each p: @pat in pat_bindings(loc.node.pat) {
+    pat_bindings(loc.node.pat) {|p|
         let ident = alt p.node { pat_bind(name) { name } };
         lhs += [{ident: ident, node: p.id}];
-    }
+    };
     {lhs: lhs, rhs: loc.node.init}
 }
 

src/comp/middle/tstate/collect_locals.rs

@@ -13,11 +13,11 @@ import syntax::ast_util::respan;
 type ctxt = {cs: @mutable [sp_constr], tcx: ty::ctxt};
 
 fn collect_local(loc: @local, cx: ctxt, v: visit::vt<ctxt>) {
-    for each p: @pat in pat_bindings(loc.node.pat) {
+    pat_bindings(loc.node.pat) {|p|
         let ident = alt p.node { pat_bind(id) { id } };
         log "collect_local: pushing " + ident;;
         *cx.cs += [respan(loc.span, ninit(p.id, ident))];
-    }
+    };
     visit::visit_local(loc, cx, v);
 }
 

src/comp/middle/tstate/pre_post_conditions.rs

@@ -109,14 +109,14 @@ fn find_pre_post_loop(fcx: fn_ctxt, l: @local, index: @expr, body: blk,
                       id: node_id) {
     find_pre_post_expr(fcx, index);
     find_pre_post_block(fcx, body);
-    for each p: @pat in pat_bindings(l.node.pat) {
+    pat_bindings(l.node.pat) {|p|
         let ident = alt p.node { pat_bind(id) { id } };
         let v_init = ninit(p.id, ident);
         relax_precond_block(fcx, bit_num(fcx, v_init) as node_id, body);
         // Hack: for-loop index variables are frequently ignored,
         // so we pretend they're used
         use_var(fcx, p.id);
-    }
+    };
 
     let loop_precond =
         seq_preconds(fcx, [expr_pp(fcx.ccx, index), block_pp(fcx.ccx, body)]);
@@ -577,9 +577,9 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                     /* LHS always becomes initialized,
                      whether or not this is a move */
                     find_pre_post_expr(fcx, an_init.expr);
-                    for each p: @pat in pat_bindings(alocal.node.pat) {
+                    pat_bindings(alocal.node.pat) {|p|
                         copy_pre_post(fcx.ccx, p.id, an_init.expr);
-                    }
+                    };
                     /* Inherit ann from initializer, and add var being
                        initialized to the postcondition */
                     copy_pre_post(fcx.ccx, id, an_init.expr);
@@ -590,18 +590,15 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                       _ { }
                     }
 
-                    for each pat: @pat in pat_bindings(alocal.node.pat) {
+                    pat_bindings(alocal.node.pat) {|pat|
                         /* FIXME: This won't be necessary when typestate
                         works well enough for pat_bindings to return a
                         refinement-typed thing. */
-                        let ident =
-                            alt pat.node {
-                              pat_bind(n) { n }
-                              _ {
-                                fcx.ccx.tcx.sess.span_bug(pat.span,
-                                                          "Impossible LHS");
-                              }
-                            };
+                        let ident = alt pat.node {
+                          pat_bind(n) { n }
+                          _ { fcx.ccx.tcx.sess.span_bug(pat.span,
+                                                        "Impossible LHS"); }
+                        };
                         alt p {
                           some(p) {
                             copy_in_postcond(fcx, id,
@@ -615,7 +612,7 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                           none. { }
                         }
                         gen(fcx, id, ninit(pat.id, ident));
-                    }
+                    };
 
                     if an_init.op == init_move && is_path(an_init.expr) {
                         forget_in_postcond(fcx, id, an_init.expr.id);
@@ -628,7 +625,7 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                                seq_preconds(fcx, [prev_pp, e_pp]));
                     /* Include the LHSs too, since those aren't in the
                      postconds of the RHSs themselves */
-                    for each pat: @pat in pat_bindings(alocal.node.pat) {
+                    pat_bindings(alocal.node.pat) {|pat|
                         alt pat.node {
                           pat_bind(n) {
                             set_in_postcond(bit_num(fcx, ninit(pat.id, n)),
@@ -639,14 +636,14 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                                                       "Impossible LHS");
                           }
                         }
-                    }
+                    };
                     copy_pre_post_(fcx.ccx, id, prev_pp.precondition,
                                    prev_pp.postcondition);
                   }
                   none. {
-                    for each p: @pat in pat_bindings(alocal.node.pat) {
+                    pat_bindings(alocal.node.pat) {|p|
                         clear_pp(node_id_to_ts_ann(fcx.ccx, p.id).conditions);
-                    }
+                    };
                     clear_pp(node_id_to_ts_ann(fcx.ccx, id).conditions);
                   }
                 }

src/comp/middle/tstate/states.rs

@@ -209,10 +209,10 @@ fn find_pre_post_state_loop(fcx: fn_ctxt, pres: prestate, l: @local,
     // Make sure the index vars are considered initialized
     // in the body
     let index_post = tritv_clone(expr_poststate(fcx.ccx, index));
-    for each p: @pat in pat_bindings(l.node.pat) {
+    pat_bindings(l.node.pat) {|p|
         let ident = alt p.node { pat_bind(name) { name } };
         set_in_poststate_ident(fcx, p.id, ident, index_post);
-    }
+    };
 
     changed |= find_pre_post_state_block(fcx, index_post, body);
 

src/comp/syntax/ast_util.rs

@@ -48,35 +48,29 @@ type pat_id_map = std::map::hashmap<str, node_id>;
 // use the node_id of their namesake in the first pattern.
 fn pat_id_map(pat: @pat) -> pat_id_map {
     let map = std::map::new_str_hash::<node_id>();
-    for each bound in pat_bindings(pat) {
+    pat_bindings(pat) {|bound|
         let name = alt bound.node { pat_bind(n) { n } };
         map.insert(name, bound.id);
-    }
+    };
     ret map;
 }
 
 // FIXME: could return a constrained type
-iter pat_bindings(pat: @pat) -> @pat {
+fn pat_bindings(pat: @pat, it: block(@pat)) {
     alt pat.node {
-      pat_bind(_) { put pat; }
-      pat_tag(_, sub) {
-        for p in sub { for each b in pat_bindings(p) { put b; } }
-      }
-      pat_rec(fields, _) {
-        for f in fields { for each b in pat_bindings(f.pat) { put b; } }
-      }
-      pat_tup(elts) {
-        for elt in elts { for each b in pat_bindings(elt) { put b; } }
-      }
-      pat_box(sub) { for each b in pat_bindings(sub) { put b; } }
-      pat_uniq(sub) { for each b in pat_bindings(sub) { put b; } }
+      pat_bind(_) { it(pat); }
+      pat_tag(_, sub) { for p in sub { pat_bindings(p, it); } }
+      pat_rec(fields, _) { for f in fields { pat_bindings(f.pat, it); } }
+      pat_tup(elts) { for elt in elts { pat_bindings(elt, it); } }
+      pat_box(sub) { pat_bindings(sub, it); }
+      pat_uniq(sub) { pat_bindings(sub, it); }
       pat_wild. | pat_lit(_) | pat_range(_, _) { }
     }
 }
 
 fn pat_binding_ids(pat: @pat) -> [node_id] {
     let found = [];
-    for each b in pat_bindings(pat) { found += [b.id]; }
+    pat_bindings(pat) {|b| found += [b.id]; };
     ret found;
 }