---

yaml
---
r: 3055
b: refs/heads/master
c: d65ad8c
h: refs/heads/master
i:
  3053: 63a2e57
  3051: 5fd2398
  3047: eb7f952
  3039: f534350
v: v3

Author: catamorphism

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: ff8af3c2db5e778dc9d8dad16538a2c38a124df7
+refs/heads/master: d65ad8c31c47a14a2b23e9991a34c02e79ec741e

trunk/src/comp/front/ast.rs

@@ -221,16 +221,17 @@ tag init_op {
 type initializer = rec(init_op op,
                        @expr expr);
 
-type local = rec(option::t[@ty] ty,
+type local_ = rec(option::t[@ty] ty,
                  bool infer,
                  ident ident,
                  option::t[initializer] init,
                  def_id id,
                  ann ann);
+type local = spanned[@local_];
 
 type decl = spanned[decl_];
 tag decl_ {
-    decl_local(@local);
+    decl_local(@local_);
     decl_item(@item);
 }
 
@@ -266,8 +267,8 @@ tag expr_ {
     expr_cast(@expr, @ty, ann);
     expr_if(@expr, block, option::t[@expr], ann);
     expr_while(@expr, block, ann);
-    expr_for(@decl, @expr, block, ann);
-    expr_for_each(@decl, @expr, block, ann);
+    expr_for(@local, @expr, block, ann);
+    expr_for_each(@local, @expr, block, ann);
     expr_do_while(block, @expr, ann);
     expr_alt(@expr, vec[arm], ann);
     expr_block(block, ann);

trunk/src/comp/front/parser.rs

@@ -1367,15 +1367,14 @@ fn parse_else_expr(&parser p) -> @ast::expr {
     }
 }
 
-fn parse_head_local(&parser p) -> @ast::decl {
+fn parse_head_local(&parser p) -> @ast::local {
     auto lo = p.get_lo_pos();
-    let @ast::local local;
-    if (is_word(p, "auto")) {
-        local = parse_auto_local(p);
-    } else {
-        local = parse_typed_local(p);
-    }
-    ret @spanned(lo, p.get_hi_pos(), ast::decl_local(local));
+    let @ast::local_ l = if (is_word(p, "auto")) {
+                           parse_auto_local(p)
+                         } else {
+                           parse_typed_local(p)
+                         };
+    ret @spanned(lo, p.get_hi_pos(), l);
 }
 
 
@@ -1567,7 +1566,7 @@ fn parse_pat(&parser p) -> @ast::pat {
 }
 
 fn parse_local_full(&option::t[@ast::ty] tyopt,
-                    &parser p) -> @ast::local {
+                    &parser p) -> @ast::local_ {
     auto ident = parse_value_ident(p);
     auto init = parse_initializer(p);
     ret @rec(ty = tyopt,
@@ -1578,12 +1577,12 @@ fn parse_local_full(&option::t[@ast::ty] tyopt,
              ann = p.get_ann());
 }
 
-fn parse_typed_local(&parser p) -> @ast::local {
+fn parse_typed_local(&parser p) -> @ast::local_ {
     auto ty = parse_ty(p);
     ret parse_local_full(some(ty), p);
 }
 
-fn parse_auto_local(&parser p) -> @ast::local {
+fn parse_auto_local(&parser p) -> @ast::local_ {
     ret parse_local_full(none[@ast::ty], p);
 }
 

trunk/src/comp/middle/alias.rs

@@ -247,15 +247,13 @@ fn arm_defnums(&ast::arm arm) -> vec[def_num] {
     ret dnums;
 }
 
-fn check_for_each(&ctx cx, &@ast::decl decl, &@ast::expr call,
+fn check_for_each(&ctx cx, &@ast::local local, &@ast::expr call,
                   &ast::block block, &scope sc, &vt[scope] v) {
     visit::visit_expr(call, sc, v);
     alt (call.node) {
         case (ast::expr_call(?f, ?args, _)) {
             auto data = check_call(cx, f, args, sc);
-            auto defnum = alt (decl.node) {
-                case (ast::decl_local(?l)) { l.id._1 }
-            };
+            auto defnum = local.node.id._1;
 
             auto new_sc = @rec(root_vars=data.root_vars,
                                block_defnum=defnum,
@@ -268,12 +266,10 @@ fn check_for_each(&ctx cx, &@ast::decl decl, &@ast::expr call,
     }
 }
 
-fn check_for(&ctx cx, &@ast::decl decl, &@ast::expr seq,
+fn check_for(&ctx cx, &@ast::local local, &@ast::expr seq,
              &ast::block block, &scope sc, &vt[scope] v) {
     visit::visit_expr(seq, sc, v);
-    auto defnum = alt (decl.node) {
-        case (ast::decl_local(?l)) { l.id._1 }
-    };
+    auto defnum = local.node.id._1;
 
     auto root = expr_root(cx, seq, false);
     auto root_def = alt (path_def_id(cx, root.ex)) {

trunk/src/comp/middle/resolve.rs

@@ -39,7 +39,7 @@ tag scope {
     scope_item(@ast::item);
     scope_fn(ast::fn_decl, vec[ast::ty_param]);
     scope_native_item(@ast::native_item);
-    scope_loop(@ast::decl); // there's only 1 decl per loop.
+    scope_loop(@ast::local_); // there's only 1 decl per loop.
     scope_block(ast::block);
     scope_arm(ast::arm);
 }
@@ -341,10 +341,10 @@ fn visit_arm_with_scope(&ast::arm a, &scopes sc, &vt[scopes] v) {
 fn visit_expr_with_scope(&@ast::expr x, &scopes sc, &vt[scopes] v) {
     auto new_sc = alt (x.node) {
         case (ast::expr_for(?d, _, _, _)) {
-            cons[scope](scope_loop(d), @sc)
+            cons[scope](scope_loop(d.node), @sc)
         }
         case (ast::expr_for_each(?d, _, _, _)) {
-            cons[scope](scope_loop(d), @sc)
+            cons[scope](scope_loop(d.node), @sc)
         }
         case (_) { sc }
     };
@@ -540,14 +540,10 @@ fn lookup_in_scope(&env e, scopes sc, &span sp, &ident id, namespace ns)
             case (scope_fn(?decl, ?ty_params)) {
                 ret lookup_in_fn(id, decl, ty_params, ns);
             }
-            case (scope_loop(?d)) {
+            case (scope_loop(?local)) {
                 if (ns == ns_value) {
-                    alt (d.node) {
-                        case (ast::decl_local(?local)) {
-                            if (str::eq(local.ident, id)) {
-                                ret some(ast::def_local(local.id));
-                            }
-                        }
+                    if (str::eq(local.ident, id)) {
+                        ret some(ast::def_local(local.id));
                     }
                 }
             }

trunk/src/comp/middle/trans.rs

@@ -4004,11 +4004,11 @@ fn trans_if(&@block_ctxt cx, &@ast::expr cond,
 }
 
 fn trans_for(&@block_ctxt cx,
-             &@ast::decl decl,
+             &@ast::local local,
              &@ast::expr seq,
              &ast::block body) -> result {
     fn inner(&@block_ctxt cx,
-             @ast::local local, ValueRef curr,
+             @ast::local_ local, ValueRef curr,
              ty::t t, ast::block body,
              @block_ctxt outer_next_cx) -> result {
 
@@ -4027,19 +4027,11 @@ fn trans_for(&@block_ctxt cx,
         ret res(next_cx, C_nil());
     }
 
-
-    let @ast::local local;
-    alt (decl.node) {
-        case (ast::decl_local(?loc)) {
-            local = loc;
-        }
-    }
-
     auto next_cx = new_sub_block_ctxt(cx, "next");
     auto seq_ty = ty::expr_ty(cx.fcx.lcx.ccx.tcx, seq);
     auto seq_res = trans_expr(cx, seq);
     auto it = iter_sequence(seq_res.bcx, seq_res.val, seq_ty,
-                            bind inner(_, local, _, _, body, next_cx));
+                            bind inner(_, local.node, _, _, body, next_cx));
     it.bcx.build.Br(next_cx.llbb);
     ret res(next_cx, it.val);
 }
@@ -4074,13 +4066,8 @@ fn collect_upvars(&@block_ctxt cx, &ast::block bloc,
         }
     }
 
-    fn walk_decl(env e, &@ast::decl decl) {
-        alt (decl.node) {
-            case (ast::decl_local(?local)) {
-                e.decls.insert(local.id, ());
-            }
-            case (_) {}
-        }
+    fn walk_local(env e, &@ast::local local) {
+        e.decls.insert(local.node.id, ());
     }
 
     let vec[ast::def_id] refs = [];
@@ -4090,7 +4077,7 @@ fn collect_upvars(&@block_ctxt cx, &ast::block bloc,
                      decls=decls,
                      def_map=cx.fcx.lcx.ccx.tcx.def_map);
 
-    auto visitor = @rec(visit_decl_pre = bind walk_decl(e, _),
+    auto visitor = @rec(visit_local_pre = bind walk_local(e, _),
                         visit_expr_pre = bind walk_expr(e, _)
                         with walk::default_visitor());
     walk::walk_block(*visitor, bloc);
@@ -4108,7 +4095,7 @@ fn collect_upvars(&@block_ctxt cx, &ast::block bloc,
 }
 
 fn trans_for_each(&@block_ctxt cx,
-                  &@ast::decl decl,
+                  &@ast::local local,
                   &@ast::expr seq,
                   &ast::block body) -> result {
     /*
@@ -4139,14 +4126,8 @@ fn trans_for_each(&@block_ctxt cx,
 
     auto lcx = cx.fcx.lcx;
     // FIXME: possibly support alias-mode here?
-    auto decl_ty = ty::mk_nil(lcx.ccx.tcx);
-    auto decl_id;
-    alt (decl.node) {
-        case (ast::decl_local(?local)) {
-            decl_ty = node_ann_type(lcx.ccx, local.ann);
-            decl_id = local.id;
-        }
-    }
+    auto decl_ty = node_ann_type(lcx.ccx, local.node.ann);
+    auto decl_id = local.node.id;
 
     auto upvars = collect_upvars(cx, body, decl_id);
     auto upvar_count = vec::len[ast::def_id](upvars);
@@ -6901,7 +6882,7 @@ fn trans_anon_obj(@block_ctxt cx, &span sp,
     ret res(bcx, pair);
 }
 
-fn init_local(&@block_ctxt cx, &@ast::local local) -> result {
+fn init_local(&@block_ctxt cx, &@ast::local_ local) -> result {
 
     // Make a note to drop this slot on the way out.
     assert (cx.fcx.lllocals.contains_key(local.id));
@@ -7064,7 +7045,7 @@ fn trans_block_cleanups(&@block_ctxt cx,
     ret bcx;
 }
 
-iter block_locals(&ast::block b) -> @ast::local {
+iter block_locals(&ast::block 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) {
@@ -7117,7 +7098,7 @@ fn alloc_ty(&@block_ctxt cx, &ty::t t) -> result {
     ret res(cx, val);
 }
 
-fn alloc_local(&@block_ctxt cx, &@ast::local local) -> result {
+fn alloc_local(&@block_ctxt cx, &@ast::local_ local) -> result {
     auto t = node_ann_type(cx.fcx.lcx.ccx, local.ann);
     auto r = alloc_ty(cx, t);
     r.bcx.fcx.lllocals.insert(local.id, r.val);
@@ -7126,7 +7107,7 @@ fn alloc_local(&@block_ctxt cx, &@ast::local local) -> result {
 
 fn trans_block(&@block_ctxt cx, &ast::block b, &out_method output) -> result {
     auto bcx = cx;
-    for each (@ast::local local in block_locals(b)) {
+    for each (@ast::local_ local in block_locals(b)) {
         *bcx = rec(sp=local_rhs_span(local, cx.sp) with *bcx);
         bcx = alloc_local(bcx, local).bcx;
     }

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

@@ -3,39 +3,7 @@ import std::option;
 import std::option::some;
 import std::option::none;
 
-import front::ast;
-import front::ast::ident;
-import front::ast::def_id;
-import front::ast::ann;
-import front::ast::item;
-import front::ast::_fn;
-import front::ast::_mod;
-import front::ast::crate;
-import front::ast::_obj;
-import front::ast::ty_param;
-import front::ast::item_fn;
-import front::ast::item_obj;
-import front::ast::item_ty;
-import front::ast::item_tag;
-import front::ast::item_const;
-import front::ast::item_mod;
-import front::ast::item_native_mod;
-import front::ast::expr;
-import front::ast::elt;
-import front::ast::field;
-import front::ast::decl;
-import front::ast::decl_local;
-import front::ast::decl_item;
-import front::ast::initializer;
-import front::ast::local;
-import front::ast::arm;
-import front::ast::stmt;
-import front::ast::stmt_decl;
-import front::ast::stmt_expr;
-import front::ast::block;
-import front::ast::block_;
-import front::ast::method;
-
+import front::ast::*;
 import middle::ty::expr_ann;
 
 import util::common::uistr;
@@ -82,13 +50,8 @@ fn collect_ids_stmt(&@stmt s, @mutable vec[uint] res) -> () {
     }
 }
 
-fn collect_ids_decl(&@decl d, @mutable vec[uint] res) -> () {
-    alt (d.node) {
-        case (decl_local(?l)) {
-            vec::push(*res, l.ann.id);
-        }
-        case (_) {}
-    }
+fn collect_ids_local(&@local l, @mutable vec[uint] res) -> () {
+    vec::push(*res, l.node.ann.id);
 }
 
 fn node_ids_in_fn(&_fn f, &span sp, &ident i, &def_id d, &ann a,
@@ -97,7 +60,7 @@ fn node_ids_in_fn(&_fn f, &span sp, &ident i, &def_id d, &ann a,
     collect_ids = rec(visit_expr_pre  = bind collect_ids_expr(_,res),
                       visit_block_pre = bind collect_ids_block(_,res),
                       visit_stmt_pre  = bind collect_ids_stmt(_,res),
-                      visit_decl_pre  = bind collect_ids_decl(_,res)
+                      visit_local_pre  = bind collect_ids_local(_,res)
                       with collect_ids);
     walk::walk_fn(collect_ids, f, sp, i, d, a);
 }

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

@@ -31,15 +31,10 @@ import util::common::respan;
 type ctxt = rec(@mutable vec[constr] cs,
                 ty::ctxt tcx);
 
-fn collect_local(&ctxt cx, &@decl d) -> () {
-    alt (d.node) {
-      case (decl_local(?loc)) {
-        log("collect_local: pushing " + loc.ident);
-        vec::push[constr](*cx.cs, respan(d.span,
-                                         ninit(loc.ident, loc.id)));
-      }
-      case (_) { ret; }
-    }
+fn collect_local(&ctxt cx, &@local loc) -> () {
+    log("collect_local: pushing " + loc.node.ident);
+    vec::push[constr](*cx.cs, respan(loc.span,
+                                     ninit(loc.node.ident, loc.node.id)));
 }
 
 fn collect_pred(&ctxt cx, &@expr e) -> () {
@@ -77,7 +72,7 @@ fn find_locals(&ty::ctxt tcx, &_fn f, &span sp, &ident i, &def_id d, &ann a)
     -> ctxt {
     let ctxt cx = rec(cs=@mutable vec::alloc[constr](0u), tcx=tcx);
     auto visitor = walk::default_visitor();
-    visitor = rec(visit_decl_pre=bind collect_local(cx,_),
+    visitor = rec(visit_local_pre=bind collect_local(cx,_),
                   visit_expr_pre=bind collect_pred(cx,_)
                   with visitor);
     walk_fn(visitor, f, sp, i, d, a);