---

yaml
---
r: 4111
b: refs/heads/master
c: 25a89e0
h: refs/heads/master
i:
  4109: 83a4c06
  4107: 4122496
  4103: 912f476
  4095: 1cb4a68
v: v3

Author: msullivan

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 552bff8a2155e9e404a3cd279a26a374188d65f7
+refs/heads/master: 25a89e068d8c5aa4a6839d02af2a23c9bf8c7c2b

trunk/src/comp/front/config.rs

@@ -78,8 +78,8 @@ fn filter_stmt(&ast::crate_cfg cfg,
     }
 }
 
-fn fold_block(&ast::crate_cfg cfg, &ast::block_ b,
-              fold::ast_fold fld) -> ast::block_  {
+fn fold_block(&ast::crate_cfg cfg, &ast::blk_ b,
+              fold::ast_fold fld) -> ast::blk_  {
     auto filter = bind filter_stmt(cfg, _);
     auto filtered_stmts = ivec::filter_map(filter, b.stmts);
     ret rec(stmts=ivec::map(fld.fold_stmt, filtered_stmts),

trunk/src/comp/front/test.rs

@@ -186,7 +186,7 @@ fn mk_tests(&test_ctxt cx) -> @ast::item {
     // The vector of test_descs for this crate
     auto test_descs = mk_test_desc_vec(cx);
 
-    let ast::block_ body_= rec(stmts = ~[],
+    let ast::blk_ body_= rec(stmts = ~[],
                                expr = option::some(test_descs),
                                id = cx.next_node_id());
     auto body = nospan(body_);
@@ -313,7 +313,7 @@ fn mk_main(&test_ctxt cx) -> @ast::item {
 
     auto test_main_call_expr = mk_test_main_call(cx);
 
-    let ast::block_ body_ = rec(stmts = ~[],
+    let ast::blk_ body_ = rec(stmts = ~[],
                                 expr = option::some(test_main_call_expr),
                                 id = cx.next_node_id());
     auto body = rec(node = body_, span = rec(lo=0u, hi=0u));

trunk/src/comp/middle/alias.rs

@@ -326,7 +326,7 @@ fn arm_defnums(&ast::arm arm) -> node_id[] {
 }
 
 fn check_for_each(&ctx cx, &@ast::local local, &@ast::expr call,
-                  &ast::block blk, &scope sc, &vt[scope] v) {
+                  &ast::blk blk, &scope sc, &vt[scope] v) {
     visit::visit_expr(call, sc, v);
     alt (call.node) {
         case (ast::expr_call(?f, ?args)) {
@@ -344,7 +344,7 @@ fn check_for_each(&ctx cx, &@ast::local local, &@ast::expr call,
     }
 }
 
-fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq, &ast::block blk,
+fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq, &ast::blk blk,
              &scope sc, &vt[scope] v) {
     visit::visit_expr(seq, sc, v);
     auto defnum = local.node.id;

trunk/src/comp/middle/resolve.rs

@@ -52,7 +52,7 @@ tag scope {
     scope_fn(ast::fn_decl, ast::ty_param[]);
     scope_native_item(@ast::native_item);
     scope_loop(@ast::local); // there's only 1 decl per loop.
-    scope_block(ast::block);
+    scope_block(ast::blk);
     scope_arm(ast::arm);
 }
 
@@ -361,7 +361,7 @@ fn visit_fn_with_scope(&@env e, &ast::_fn f, &ast::ty_param[] tp, &span sp,
                     cons(scope_fn(f.decl, tp), @sc), v);
 }
 
-fn visit_block_with_scope(&ast::block b, &scopes sc, &vt[scopes] v) {
+fn visit_block_with_scope(&ast::blk b, &scopes sc, &vt[scopes] v) {
     visit::visit_block(b, cons(scope_block(b), @sc), v);
 }
 
@@ -781,7 +781,7 @@ fn lookup_in_obj(&ident name, &ast::_obj ob, &ast::ty_param[] ty_params,
     }
 }
 
-fn lookup_in_block(&ident name, &ast::block_ b, namespace ns) ->
+fn lookup_in_block(&ident name, &ast::blk_ b, namespace ns) ->
    option::t[def] {
     for (@ast::stmt st in b.stmts) {
         alt (st.node) {
@@ -1319,7 +1319,7 @@ fn check_arm(@env e, &ast::arm a, &() x, &vt[()] v) {
     }
 }
 
-fn check_block(@env e, &ast::block b, &() x, &vt[()] v) {
+fn check_block(@env e, &ast::blk b, &() x, &vt[()] v) {
     visit::visit_block(b, x, v);
     auto values = checker(*e, "value");
     auto types = checker(*e, "type");

trunk/src/comp/middle/trans.rs

@@ -3696,7 +3696,7 @@ fn join_branches(&@block_ctxt parent_cx, &result[] ins) -> @block_ctxt {
 
 tag out_method { return; save_in(ValueRef); }
 
-fn trans_if(&@block_ctxt cx, &@ast::expr cond, &ast::block thn,
+fn trans_if(&@block_ctxt cx, &@ast::expr cond, &ast::blk thn,
             &option::t[@ast::expr] els, ast::node_id id, &out_method output)
     -> result {
     auto cond_res = trans_expr(cx, cond);
@@ -3731,11 +3731,11 @@ fn trans_if(&@block_ctxt cx, &@ast::expr cond, &ast::block thn,
 }
 
 fn trans_for(&@block_ctxt cx, &@ast::local local, &@ast::expr seq,
-             &ast::block body) -> result {
+             &ast::blk body) -> result {
     // FIXME: We bind to an alias here to avoid a segfault... this is
     // obviously a bug.
     fn inner(&@block_ctxt cx, @ast::local local, ValueRef curr, ty::t t,
-             &ast::block body, @block_ctxt outer_next_cx) -> result {
+             &ast::blk body, @block_ctxt outer_next_cx) -> result {
         auto next_cx = new_sub_block_ctxt(cx, "next");
         auto scope_cx =
             new_loop_scope_block_ctxt(cx, option::some[@block_ctxt](next_cx),
@@ -3906,7 +3906,7 @@ fn load_environment(&@block_ctxt cx, &@fn_ctxt fcx,
 }
 
 fn trans_for_each(&@block_ctxt cx, &@ast::local local, &@ast::expr seq,
-                  &ast::block body) -> result {
+                  &ast::blk body) -> result {
     /*
      * The translation is a little .. complex here. Code like:
      *
@@ -3985,7 +3985,7 @@ fn trans_for_each(&@block_ctxt cx, &@ast::local local, &@ast::expr seq,
     }
 }
 
-fn trans_while(&@block_ctxt cx, &@ast::expr cond, &ast::block body) ->
+fn trans_while(&@block_ctxt cx, &@ast::expr cond, &ast::blk body) ->
    result {
     auto cond_cx = new_scope_block_ctxt(cx, "while cond");
     auto next_cx = new_sub_block_ctxt(cx, "next");
@@ -4001,7 +4001,7 @@ fn trans_while(&@block_ctxt cx, &@ast::expr cond, &ast::block body) ->
     ret rslt(next_cx, C_nil());
 }
 
-fn trans_do_while(&@block_ctxt cx, &ast::block body, &@ast::expr cond) ->
+fn trans_do_while(&@block_ctxt cx, &ast::blk body, &@ast::expr cond) ->
    result {
     auto next_cx = new_sub_block_ctxt(cx, "next");
     auto body_cx =
@@ -6256,7 +6256,7 @@ fn trans_block_cleanups(&@block_ctxt cx, &@block_ctxt cleanup_cx)
     ret bcx;
 }
 
-iter block_locals(&ast::block b) -> @ast::local {
+iter block_locals(&ast::blk b) -> @ast::local {
     // FIXME: putting from inside an iter block doesn't work, so we can't
     // use the index here.
     for (@ast::stmt s in b.node.stmts) {
@@ -6343,7 +6343,7 @@ fn alloc_local(&@block_ctxt cx, &@ast::local local) -> result {
     ret r;
 }
 
-fn trans_block(&@block_ctxt cx, &ast::block b, &out_method output) -> result {
+fn trans_block(&@block_ctxt cx, &ast::blk b, &out_method output) -> result {
     auto bcx = cx;
     for each (@ast::local local in block_locals(b)) {
         // FIXME Update bcx.sp

trunk/src/comp/middle/trans_dps.rs

@@ -446,7 +446,7 @@ fn trans_recv(&@block_ctxt bcx, &dest dest, &@ast::expr expr) -> @block_ctxt {
     ret bcx;    // TODO
 }
 
-fn trans_block(&@block_ctxt cx, &dest dest, &ast::block blk)
+fn trans_block(&@block_ctxt cx, &dest dest, &ast::blk blk)
         -> @block_ctxt {
     auto bcx = cx;
     for each (@ast::local local in trans::block_locals(blk)) {

trunk/src/comp/middle/tstate/annotate.rs

@@ -27,7 +27,7 @@ fn collect_ids_expr(&@expr e, @mutable node_id[] rs) {
     *rs += ~[e.id];
 }
 
-fn collect_ids_block(&block b, @mutable node_id[] rs) {
+fn collect_ids_block(&blk b, @mutable node_id[] rs) {
     *rs += ~[b.node.id];
 }
 

trunk/src/comp/middle/tstate/auxiliary.rs

@@ -332,7 +332,7 @@ fn stmt_pp(&crate_ctxt ccx, &stmt s) -> pre_and_post {
 
 
 /* fails if b has no annotation */
-fn block_pp(&crate_ctxt ccx, &block b) -> pre_and_post {
+fn block_pp(&crate_ctxt ccx, &blk b) -> pre_and_post {
     log "block_pp";
     ret node_id_to_ts_ann(ccx, b.node.id).conditions;
 }
@@ -347,7 +347,7 @@ fn clear_precond(&crate_ctxt ccx, node_id id) {
     ann::clear(pp.conditions.precondition);
 }
 
-fn block_states(&crate_ctxt ccx, &block b) -> pre_and_post_state {
+fn block_states(&crate_ctxt ccx, &blk b) -> pre_and_post_state {
     log "block_states";
     ret node_id_to_ts_ann(ccx, b.node.id).states;
 }
@@ -392,19 +392,19 @@ fn stmt_poststate(&crate_ctxt ccx, &stmt s) -> poststate {
     ret stmt_states(ccx, s).poststate;
 }
 
-fn block_precond(&crate_ctxt ccx, &block b) -> precond {
+fn block_precond(&crate_ctxt ccx, &blk b) -> precond {
     ret block_pp(ccx, b).precondition;
 }
 
-fn block_postcond(&crate_ctxt ccx, &block b) -> postcond {
+fn block_postcond(&crate_ctxt ccx, &blk b) -> postcond {
     ret block_pp(ccx, b).postcondition;
 }
 
-fn block_prestate(&crate_ctxt ccx, &block b) -> prestate {
+fn block_prestate(&crate_ctxt ccx, &blk b) -> prestate {
     ret block_states(ccx, b).prestate;
 }
 
-fn block_poststate(&crate_ctxt ccx, &block b) -> poststate {
+fn block_poststate(&crate_ctxt ccx, &blk b) -> poststate {
     ret block_states(ccx, b).poststate;
 }
 

trunk/src/comp/middle/tstate/bitvectors.rs

@@ -153,7 +153,7 @@ fn declare_var(&fn_ctxt fcx, &tsconstr c, prestate pre) -> prestate {
     ret rslt;
 }
 
-fn relax_precond_block_non_recursive(&fn_ctxt fcx, node_id i, &block b) {
+fn relax_precond_block_non_recursive(&fn_ctxt fcx, node_id i, &blk b) {
     relax_precond(i as uint, block_precond(fcx.ccx, b));
 }
 
@@ -165,7 +165,7 @@ fn relax_precond_stmt(&fn_ctxt fcx, node_id i, &@stmt s) {
     relax_precond(i as uint, stmt_precond(fcx.ccx, *s));
 }
 
-fn relax_precond_block(&fn_ctxt fcx, node_id i, &block b) {
+fn relax_precond_block(&fn_ctxt fcx, node_id i, &blk b) {
     relax_precond_block_non_recursive(fcx, i, b);
     // FIXME: should use visit instead
     // could at least generalize this pattern

trunk/src/comp/middle/tstate/pre_post_conditions.rs

@@ -131,7 +131,7 @@ fn find_pre_post_exprs(&fn_ctxt fcx, &(@expr)[] args, node_id id) {
                      seq_postconds(fcx, ivec::map(get_post, pps)));
 }
 
-fn find_pre_post_loop(&fn_ctxt fcx, &@local l, &@expr index, &block body,
+fn find_pre_post_loop(&fn_ctxt fcx, &@local l, &@expr index, &blk body,
                       node_id id) {
     find_pre_post_expr(fcx, index);
     find_pre_post_block(fcx, body);
@@ -152,7 +152,7 @@ fn find_pre_post_loop(&fn_ctxt fcx, &@local l, &@expr index, &block body,
 // Generates a pre/post assuming that a is the
 // annotation for an if-expression with consequent conseq
 // and alternative maybe_alt
-fn join_then_else(&fn_ctxt fcx, &@expr antec, &block conseq,
+fn join_then_else(&fn_ctxt fcx, &@expr antec, &blk conseq,
                   &option::t[@expr] maybe_alt, node_id id, &if_ty chck) {
     find_pre_post_expr(fcx, antec);
     find_pre_post_block(fcx, conseq);
@@ -644,7 +644,7 @@ fn find_pre_post_stmt(&fn_ctxt fcx, &stmt s) {
     }
 }
 
-fn find_pre_post_block(&fn_ctxt fcx, block b) {
+fn find_pre_post_block(&fn_ctxt fcx, blk b) {
     /* Want to say that if there is a break or cont in this
      block, then that invalidates the poststate upheld by
     any of the stmts after it.

trunk/src/comp/middle/tstate/states.rs

@@ -177,7 +177,8 @@ fn find_pre_post_state_exprs(&fn_ctxt fcx, &prestate pres, node_id id,
 }
 
 fn find_pre_post_state_loop(&fn_ctxt fcx, prestate pres, &@local l,
-                            &@expr index, &block body, node_id id) -> bool {
+                            &@expr index, &blk body, node_id id)
+    -> bool {
     auto loop_pres = intersect_states(pres,
                                       block_poststate(fcx.ccx, body));
 
@@ -217,7 +218,7 @@ fn gen_if_local(&fn_ctxt fcx, &poststate p, &@expr e) -> bool {
     }
 }
 
-fn join_then_else(&fn_ctxt fcx, &@expr antec, &block conseq,
+fn join_then_else(&fn_ctxt fcx, &@expr antec, &blk conseq,
                   &option::t[@expr] maybe_alt, node_id id, &if_ty chk,
                   &prestate pres) -> bool {
     auto changed = set_prestate_ann(fcx.ccx, id, pres) |
@@ -692,7 +693,7 @@ fn find_pre_post_state_stmt(&fn_ctxt fcx, &prestate pres, @stmt s) -> bool {
 
 /* Updates the pre- and post-states of statements in the block,
    returns a boolean flag saying whether any pre- or poststates changed */
-fn find_pre_post_state_block(&fn_ctxt fcx, &prestate pres0, &block b)
+fn find_pre_post_state_block(&fn_ctxt fcx, &prestate pres0, &blk b)
     -> bool {
     /* First, set the pre-states and post-states for every expression */
 

trunk/src/comp/middle/ty.rs

@@ -1874,7 +1874,7 @@ fn ty_var_id(&ctxt cx, t typ) -> int {
 
 
 // Type accessors for AST nodes
-fn block_ty(&ctxt cx, &ast::block b) -> t {
+fn block_ty(&ctxt cx, &ast::blk b) -> t {
     ret node_id_to_type(cx, b.node.id);
 }
 

trunk/src/comp/middle/typeck.rs

@@ -1105,7 +1105,7 @@ mod writeback {
     fn visit_expr_pre(@wb_ctxt wbcx, &@ast::expr e) {
         resolve_type_vars_for_node(wbcx, e.span, e.id);
     }
-    fn visit_block_pre(@wb_ctxt wbcx, &ast::block b) {
+    fn visit_block_pre(@wb_ctxt wbcx, &ast::blk b) {
         resolve_type_vars_for_node(wbcx, b.span, b.node.id);
     }
     fn visit_pat_pre(@wb_ctxt wbcx, &@ast::pat p) {
@@ -1147,7 +1147,7 @@ mod writeback {
     }
     fn keep_going(@wb_ctxt wbcx) -> bool { !wbcx.ignore && wbcx.success }
 
-    fn resolve_type_vars_in_block(&@fn_ctxt fcx, &ast::block blk) -> bool {
+    fn resolve_type_vars_in_block(&@fn_ctxt fcx, &ast::blk blk) -> bool {
         auto wbcx = @rec(fcx = fcx,
                          mutable ignore = false,
                          mutable success = true);
@@ -1628,7 +1628,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
     // A generic function for checking for or for-each loops
 
     fn check_for_or_for_each(&@fn_ctxt fcx, &@ast::local local,
-                             &ty::t element_ty, &ast::block body,
+                             &ty::t element_ty, &ast::blk body,
                              ast::node_id node_id) {
         check_decl_local(fcx, local);
         check_block(fcx, body);
@@ -1687,7 +1687,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) {
 
     // A generic function for checking the then and else in an if
     // or if-check
-    fn check_then_else(&@fn_ctxt fcx, &ast::block thn,
+    fn check_then_else(&@fn_ctxt fcx, &ast::blk thn,
                        &option::t[@ast::expr] elsopt,
                        ast::node_id id, &span sp) {
         check_block(fcx, thn);
@@ -2598,7 +2598,7 @@ fn check_stmt(&@fn_ctxt fcx, &@ast::stmt stmt) {
     write::nil_ty(fcx.ccx.tcx, node_id);
 }
 
-fn check_block(&@fn_ctxt fcx, &ast::block blk) {
+fn check_block(&@fn_ctxt fcx, &ast::blk blk) {
     for (@ast::stmt s in blk.node.stmts) { check_stmt(fcx, s); }
     alt (blk.node.expr) {
         case (none) { write::nil_ty(fcx.ccx.tcx, blk.node.id); }