diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs index 5dd8b28cbe1..6742c00ccfe 100644 --- a/src/comp/middle/alias.rs +++ b/src/comp/middle/alias.rs @@ -49,7 +49,7 @@ fn check_crate(@ty::ctxt tcx, &@ast::crate crate) { visit_item=bind visit_item(cx, _, _, _), visit_expr=bind visit_expr(cx, _, _, _) with *visit::default_visitor[scope]()); - visit::visit_crate(*crate, [], visit::vtor(v)); + visit::visit_crate(*crate, [], visit::mk_vt(v)); tcx.sess.abort_if_errors(); } @@ -59,7 +59,7 @@ fn visit_fn(@ctx cx, &ast::_fn f, &ast::ty_param[] tp, &span sp, for (ast::arg arg_ in f.decl.inputs) { cx.local_map.insert(arg_.id, arg(arg_.mode)); } - vt(v).visit_block(f.body, [], v); + v.visit_block(f.body, [], v); } fn visit_item(@ctx cx, &@ast::item i, &scope sc, &vt[scope] v) { diff --git a/src/comp/middle/ast_map.rs b/src/comp/middle/ast_map.rs index 9b19e6a9970..aa71242f9c8 100644 --- a/src/comp/middle/ast_map.rs +++ b/src/comp/middle/ast_map.rs @@ -23,7 +23,7 @@ fn map_crate(&crate c) -> map { visit_native_item=bind map_native_item(map, _, _, _), visit_expr=bind map_expr(map, _, _, _) with *visit::default_visitor[()]()); - visit::visit_crate(c, (), visit::vtor(v_map)); + visit::visit_crate(c, (), visit::mk_vt(v_map)); ret map; } diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs index e916fb8ebbb..5de67552e7f 100644 --- a/src/comp/middle/resolve.rs +++ b/src/comp/middle/resolve.rs @@ -155,7 +155,7 @@ fn map_crate(&@env e, &@ast::crate c) { visit_item=bind index_i(e, _, _, _) with *visit::default_visitor[scopes]()); visit::visit_crate(*c, cons(scope_crate(c), @nil), - visit::vtor(v_map_mod)); + visit::mk_vt(v_map_mod)); // Register the top-level mod e.mod_map.insert(-1, @@ -200,7 +200,7 @@ fn map_crate(&@env e, &@ast::crate c) { visit_item=visit_item_with_scope with *visit::default_visitor[scopes]()); visit::visit_crate(*c, cons(scope_crate(c), @nil), - visit::vtor(v_link_glob)); + visit::mk_vt(v_link_glob)); fn link_glob(@env e, &@ast::view_item vi, &scopes sc, &vt[scopes] v) { fn find_mod(@env e, scopes sc) -> @indexed_mod { alt (sc) { @@ -257,7 +257,7 @@ fn resolve_names(&@env e, &@ast::crate c) { visit_constr=bind walk_constr(e, _, _, _), visit_fn=bind visit_fn_with_scope(e, _, _, _, _, _, _, _) with *visit::default_visitor()); - visit::visit_crate(*c, cons(scope_crate(c), @nil), visit::vtor(v)); + visit::visit_crate(*c, cons(scope_crate(c), @nil), visit::mk_vt(v)); e.sess.abort_if_errors(); fn walk_expr(@env e, &@ast::expr exp, &scopes sc, &vt[scopes] v) { @@ -1183,7 +1183,7 @@ fn check_for_collisions(&@env e, &ast::crate c) { visit_block=bind check_block(e, _, _, _), visit_arm=bind check_arm(e, _, _, _) with *visit::default_visitor()); - visit::visit_crate(c, (), visit::vtor(v)); + visit::visit_crate(c, (), visit::mk_vt(v)); } fn check_mod_name(&env e, &ident name, list[mod_index_entry] entries) { diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index 061fe320a71..461a42ebc42 100644 --- a/src/comp/middle/trans.rs +++ b/src/comp/middle/trans.rs @@ -9108,8 +9108,8 @@ fn collect_items(&@crate_ctxt ccx, @ast::crate crate) { visit_item=bind collect_item_1(ccx, _, _, _) with *visitor0); auto visitor2 = @rec(visit_item=bind collect_item_2(ccx, _, _, _) with *visitor0); - visit::visit_crate(*crate, ~[], visit::vtor(visitor1)); - visit::visit_crate(*crate, ~[], visit::vtor(visitor2)); + visit::visit_crate(*crate, ~[], visit::mk_vt(visitor1)); + visit::visit_crate(*crate, ~[], visit::mk_vt(visitor2)); } fn collect_tag_ctor(@crate_ctxt ccx, &@ast::item i, &str[] pt, &vt[str[]] v) { @@ -9133,7 +9133,7 @@ fn collect_tag_ctors(&@crate_ctxt ccx, @ast::crate crate) { auto visitor = @rec(visit_item=bind collect_tag_ctor(ccx, _, _, _) with *visit::default_visitor()); - visit::visit_crate(*crate, ~[], visit::vtor(visitor)); + visit::visit_crate(*crate, ~[], visit::mk_vt(visitor)); } @@ -9178,7 +9178,7 @@ fn trans_constants(&@crate_ctxt ccx, @ast::crate crate) { auto visitor = @rec(visit_item=bind trans_constant(ccx, _, _, _) with *visit::default_visitor()); - visit::visit_crate(*crate, ~[], visit::vtor(visitor)); + visit::visit_crate(*crate, ~[], visit::mk_vt(visitor)); } fn vp2i(&@block_ctxt cx, ValueRef v) -> ValueRef { diff --git a/src/comp/middle/tstate/collect_locals.rs b/src/comp/middle/tstate/collect_locals.rs index 95b0723eb34..61fb3541a73 100644 --- a/src/comp/middle/tstate/collect_locals.rs +++ b/src/comp/middle/tstate/collect_locals.rs @@ -73,12 +73,11 @@ fn find_locals(&ty::ctxt tcx, &_fn f, &ty_param[] tps, &span sp, &fn_ident i, let ctxt cx = rec(cs=@mutable ~[], tcx=tcx); auto visitor = visit::default_visitor[ctxt](); - visitor = - @rec(visit_local=collect_local, - visit_expr=collect_pred, - visit_fn=do_nothing - with *visitor); - visit::visit_fn(f, tps, sp, i, id, cx, visit::vtor(visitor)); + visitor = @rec(visit_local=collect_local, + visit_expr=collect_pred, + visit_fn=do_nothing + with *visitor); + visit::visit_fn(f, tps, sp, i, id, cx, visit::mk_vt(visitor)); ret cx; } diff --git a/src/comp/syntax/visit.rs b/src/comp/syntax/visit.rs index 984bb4f6d94..c6e4d1911d4 100644 --- a/src/comp/syntax/visit.rs +++ b/src/comp/syntax/visit.rs @@ -15,9 +15,7 @@ import codemap::span; // Lots of redundant indirection and refcounting. Our typesystem doesn't do // circular types, so the visitor record can not hold functions that take // visitors. A vt tag is used to break the cycle. -tag vt[E] { vtor(visitor[E]); } - -fn vt[E](&vt[E] x) -> visitor[E] { alt (x) { case (vtor(?v)) { ret v; } } } +tag vt[E] { mk_vt(visitor[E]); } type visitor[E] = @rec(fn(&_mod, &span, &E, &vt[E]) visit_mod, @@ -54,7 +52,7 @@ fn default_visitor[E]() -> visitor[E] { } fn visit_crate[E](&crate c, &E e, &vt[E] v) { - vt(v).visit_mod(c.node.module, c.span, e, v); + v.visit_mod(c.node.module, c.span, e, v); } fn visit_crate_directive[E](&@crate_directive cd, &E e, &vt[E] v) { @@ -65,15 +63,15 @@ fn visit_crate_directive[E](&@crate_directive cd, &E e, &vt[E] v) { visit_crate_directive(cdir, e, v); } } - case (cdir_view_item(?vi)) { vt(v).visit_view_item(vi, e, v); } + case (cdir_view_item(?vi)) { v.visit_view_item(vi, e, v); } case (cdir_syntax(_)) { } case (cdir_auth(_, _)) { } } } fn visit_mod[E](&_mod m, &span sp, &E e, &vt[E] v) { - for (@view_item vi in m.view_items) { vt(v).visit_view_item(vi, e, v); } - for (@item i in m.items) { vt(v).visit_item(i, e, v); } + for (@view_item vi in m.view_items) { v.visit_view_item(vi, e, v); } + for (@item i in m.items) { v.visit_item(i, e, v); } } fn visit_view_item[E](&@view_item vi, &E e, &vt[E] v) { } @@ -81,55 +79,54 @@ fn visit_view_item[E](&@view_item vi, &E e, &vt[E] v) { } fn visit_local[E](&@local loc, &E e, &vt[E] v) { alt (loc.node.ty) { case (none) { } - case (some(?t)) { vt(v).visit_ty(t, e, v); } + case (some(?t)) { v.visit_ty(t, e, v); } } alt (loc.node.init) { case (none) { } - case (some(?i)) { vt(v).visit_expr(i.expr, e, v); } + case (some(?i)) { v.visit_expr(i.expr, e, v); } } } fn visit_item[E](&@item i, &E e, &vt[E] v) { alt (i.node) { case (item_const(?t, ?ex)) { - vt(v).visit_ty(t, e, v); - vt(v).visit_expr(ex, e, v); + v.visit_ty(t, e, v); + v.visit_expr(ex, e, v); } case (item_fn(?f, ?tp)) { - vt(v).visit_fn(f, tp, i.span, some(i.ident), i.id, e, v); + v.visit_fn(f, tp, i.span, some(i.ident), i.id, e, v); } - case (item_mod(?m)) { vt(v).visit_mod(m, i.span, e, v); } + case (item_mod(?m)) { v.visit_mod(m, i.span, e, v); } case (item_native_mod(?nm)) { for (@view_item vi in nm.view_items) { - vt(v).visit_view_item(vi, e, v); + v.visit_view_item(vi, e, v); } for (@native_item ni in nm.items) { - vt(v).visit_native_item(ni, e, v); + v.visit_native_item(ni, e, v); } } - case (item_ty(?t, _)) { vt(v).visit_ty(t, e, v); } + case (item_ty(?t, _)) { v.visit_ty(t, e, v); } case (item_res(?f, ?dtor_id, ?tps, _)) { - vt(v).visit_fn(f, tps, i.span, some(i.ident), dtor_id, e, v); + v.visit_fn(f, tps, i.span, some(i.ident), dtor_id, e, v); } case (item_tag(?variants, _)) { for (variant vr in variants) { for (variant_arg va in vr.node.args) { - vt(v).visit_ty(va.ty, e, v); + v.visit_ty(va.ty, e, v); } } } case (item_obj(?ob, _, _)) { - for (obj_field f in ob.fields) { vt(v).visit_ty(f.ty, e, v); } + for (obj_field f in ob.fields) { v.visit_ty(f.ty, e, v); } for (@method m in ob.methods) { - vt(v).visit_fn(m.node.meth, ~[], m.span, some(m.node.ident), - m.node.id, e, v); + v.visit_fn(m.node.meth, ~[], m.span, some(m.node.ident), + m.node.id, e, v); } alt (ob.dtor) { case (none) { } case (some(?m)) { - vt(v).visit_fn(m.node.meth, ~[], m.span, - some(m.node.ident), - m.node.id, e, v); + v.visit_fn(m.node.meth, ~[], m.span, some(m.node.ident), + m.node.id, e, v); } } } @@ -148,37 +145,37 @@ fn visit_ty[E](&@ty t, &E e, &vt[E] v) { case (ty_char) { /* no-op */ } case (ty_str) { /* no-op */ } case (ty_istr) { /* no-op */ } - case (ty_box(?mt)) { vt(v).visit_ty(mt.ty, e, v); } - case (ty_vec(?mt)) { vt(v).visit_ty(mt.ty, e, v); } - case (ty_ivec(?mt)) { vt(v).visit_ty(mt.ty, e, v); } - case (ty_ptr(?mt)) { vt(v).visit_ty(mt.ty, e, v); } - case (ty_port(?t)) { vt(v).visit_ty(t, e, v); } - case (ty_chan(?t)) { vt(v).visit_ty(t, e, v); } + case (ty_box(?mt)) { v.visit_ty(mt.ty, e, v); } + case (ty_vec(?mt)) { v.visit_ty(mt.ty, e, v); } + case (ty_ivec(?mt)) { v.visit_ty(mt.ty, e, v); } + case (ty_ptr(?mt)) { v.visit_ty(mt.ty, e, v); } + case (ty_port(?t)) { v.visit_ty(t, e, v); } + case (ty_chan(?t)) { v.visit_ty(t, e, v); } case (ty_task) { /* no-op */ } case (ty_tup(?mts)) { - for (mt mt in mts) { vt(v).visit_ty(mt.ty, e, v); } + for (mt mt in mts) { v.visit_ty(mt.ty, e, v); } } case (ty_rec(?flds)) { - for (ty_field f in flds) { vt(v).visit_ty(f.node.mt.ty, e, v); } + for (ty_field f in flds) { v.visit_ty(f.node.mt.ty, e, v); } } case (ty_fn(_, ?args, ?out, _, ?constrs)) { - for (ty_arg a in args) { vt(v).visit_ty(a.node.ty, e, v); } - for (@constr c in constrs) { vt(v).visit_constr(c, e, v); } - vt(v).visit_ty(out, e, v); + for (ty_arg a in args) { v.visit_ty(a.node.ty, e, v); } + for (@constr c in constrs) { v.visit_constr(c, e, v); } + v.visit_ty(out, e, v); } case (ty_obj(?tmeths)) { for (ty_method m in tmeths) { for (ty_arg a in m.node.inputs) { - vt(v).visit_ty(a.node.ty, e, v); + v.visit_ty(a.node.ty, e, v); } - vt(v).visit_ty(m.node.output, e, v); + v.visit_ty(m.node.output, e, v); } } case (ty_path(?p, _)) { - for (@ty tp in p.node.types) { vt(v).visit_ty(tp, e, v); } + for (@ty tp in p.node.types) { v.visit_ty(tp, e, v); } } case (ty_type) { /* no-op */ } - case (ty_constr(?t, _)) { vt(v).visit_ty(t, e, v); } + case (ty_constr(?t, _)) { v.visit_ty(t, e, v); } } } @@ -190,8 +187,8 @@ fn visit_constr[E](&@constr c, &E e, &vt[E] v) { fn visit_pat[E](&@pat p, &E e, &vt[E] v) { alt (p.node) { case (pat_tag(?path, ?children)) { - for (@ty tp in path.node.types) { vt(v).visit_ty(tp, e, v); } - for (@pat child in children) { vt(v).visit_pat(child, e, v); } + for (@ty tp in path.node.types) { v.visit_ty(tp, e, v); } + for (@pat child in children) { v.visit_pat(child, e, v); } } case (_) { } } @@ -205,26 +202,26 @@ fn visit_native_item[E](&@native_item ni, &E e, &vt[E] v) { } fn visit_fn_decl[E](&fn_decl fd, &E e, &vt[E] v) { - for (arg a in fd.inputs) { vt(v).visit_ty(a.ty, e, v); } - for (@constr c in fd.constraints) { vt(v).visit_constr(c, e, v); } - vt(v).visit_ty(fd.output, e, v); + for (arg a in fd.inputs) { v.visit_ty(a.ty, e, v); } + for (@constr c in fd.constraints) { v.visit_constr(c, e, v); } + v.visit_ty(fd.output, e, v); } fn visit_fn[E](&_fn f, &ty_param[] tp, &span sp, &fn_ident i, node_id id, &E e, &vt[E] v) { visit_fn_decl(f.decl, e, v); - vt(v).visit_block(f.body, e, v); + v.visit_block(f.body, e, v); } fn visit_block[E](&block b, &E e, &vt[E] v) { - for (@stmt s in b.node.stmts) { vt(v).visit_stmt(s, e, v); } + for (@stmt s in b.node.stmts) { v.visit_stmt(s, e, v); } visit_expr_opt(b.node.expr, e, v); } fn visit_stmt[E](&@stmt s, &E e, &vt[E] v) { alt (s.node) { - case (stmt_decl(?d, _)) { vt(v).visit_decl(d, e, v); } - case (stmt_expr(?ex, _)) { vt(v).visit_expr(ex, e, v); } + case (stmt_decl(?d, _)) { v.visit_decl(d, e, v); } + case (stmt_expr(?ex, _)) { v.visit_expr(ex, e, v); } case (stmt_crate_directive(?cd)) { visit_crate_directive(cd, e, v); } } } @@ -232,131 +229,131 @@ fn visit_stmt[E](&@stmt s, &E e, &vt[E] v) { fn visit_decl[E](&@decl d, &E e, &vt[E] v) { alt (d.node) { case (decl_local(?loc)) { - vt(v).visit_local(loc, e, v); + v.visit_local(loc, e, v); } - case (decl_item(?it)) { vt(v).visit_item(it, e, v); } + case (decl_item(?it)) { v.visit_item(it, e, v); } } } fn visit_expr_opt[E](option::t[@expr] eo, &E e, &vt[E] v) { alt (eo) { case (none) { } - case (some(?ex)) { vt(v).visit_expr(ex, e, v); } + case (some(?ex)) { v.visit_expr(ex, e, v); } } } fn visit_exprs[E](&(@expr)[] exprs, &E e, &vt[E] v) { - for (@expr ex in exprs) { vt(v).visit_expr(ex, e, v); } + for (@expr ex in exprs) { v.visit_expr(ex, e, v); } } fn visit_expr[E](&@expr ex, &E e, &vt[E] v) { alt (ex.node) { case (expr_vec(?es, _, _)) { visit_exprs(es, e, v); } case (expr_tup(?elts)) { - for (elt el in elts) { vt(v).visit_expr(el.expr, e, v); } + for (elt el in elts) { v.visit_expr(el.expr, e, v); } } case (expr_rec(?flds, ?base)) { - for (field f in flds) { vt(v).visit_expr(f.node.expr, e, v); } + for (field f in flds) { v.visit_expr(f.node.expr, e, v); } visit_expr_opt(base, e, v); } case (expr_call(?callee, ?args)) { - vt(v).visit_expr(callee, e, v); + v.visit_expr(callee, e, v); visit_exprs(args, e, v); } case (expr_self_method(_)) { } case (expr_bind(?callee, ?args)) { - vt(v).visit_expr(callee, e, v); + v.visit_expr(callee, e, v); for (option::t[@expr] eo in args) { visit_expr_opt(eo, e, v); } } case (expr_spawn(_, _, ?callee, ?args)) { - vt(v).visit_expr(callee, e, v); + v.visit_expr(callee, e, v); visit_exprs(args, e, v); } case (expr_binary(_, ?a, ?b)) { - vt(v).visit_expr(a, e, v); - vt(v).visit_expr(b, e, v); + v.visit_expr(a, e, v); + v.visit_expr(b, e, v); } - case (expr_unary(_, ?a)) { vt(v).visit_expr(a, e, v); } + case (expr_unary(_, ?a)) { v.visit_expr(a, e, v); } case (expr_lit(_)) { } case (expr_cast(?x, ?t)) { - vt(v).visit_expr(x, e, v); - vt(v).visit_ty(t, e, v); + v.visit_expr(x, e, v); + v.visit_ty(t, e, v); } case (expr_if(?x, ?b, ?eo)) { - vt(v).visit_expr(x, e, v); - vt(v).visit_block(b, e, v); + v.visit_expr(x, e, v); + v.visit_block(b, e, v); visit_expr_opt(eo, e, v); } case (expr_if_check(?x, ?b, ?eo)) { - vt(v).visit_expr(x, e, v); - vt(v).visit_block(b, e, v); + v.visit_expr(x, e, v); + v.visit_block(b, e, v); visit_expr_opt(eo, e, v); } case (expr_ternary(?c, ?t, ?el)) { - vt(v).visit_expr(c, e, v); - vt(v).visit_expr(t, e, v); - vt(v).visit_expr(el, e, v); + v.visit_expr(c, e, v); + v.visit_expr(t, e, v); + v.visit_expr(el, e, v); } case (expr_while(?x, ?b)) { - vt(v).visit_expr(x, e, v); - vt(v).visit_block(b, e, v); + v.visit_expr(x, e, v); + v.visit_block(b, e, v); } case (expr_for(?dcl, ?x, ?b)) { - vt(v).visit_local(dcl, e, v); - vt(v).visit_expr(x, e, v); - vt(v).visit_block(b, e, v); + v.visit_local(dcl, e, v); + v.visit_expr(x, e, v); + v.visit_block(b, e, v); } case (expr_for_each(?dcl, ?x, ?b)) { - vt(v).visit_local(dcl, e, v); - vt(v).visit_expr(x, e, v); - vt(v).visit_block(b, e, v); + v.visit_local(dcl, e, v); + v.visit_expr(x, e, v); + v.visit_block(b, e, v); } case (expr_do_while(?b, ?x)) { - vt(v).visit_block(b, e, v); - vt(v).visit_expr(x, e, v); + v.visit_block(b, e, v); + v.visit_expr(x, e, v); } case (expr_alt(?x, ?arms)) { - vt(v).visit_expr(x, e, v); - for (arm a in arms) { vt(v).visit_arm(a, e, v); } + v.visit_expr(x, e, v); + for (arm a in arms) { v.visit_arm(a, e, v); } } case (expr_fn(?f)) { - vt(v).visit_fn(f, ~[], ex.span, none, ex.id, e, v); + v.visit_fn(f, ~[], ex.span, none, ex.id, e, v); } - case (expr_block(?b)) { vt(v).visit_block(b, e, v); } + case (expr_block(?b)) { v.visit_block(b, e, v); } case (expr_assign(?a, ?b)) { - vt(v).visit_expr(b, e, v); - vt(v).visit_expr(a, e, v); + v.visit_expr(b, e, v); + v.visit_expr(a, e, v); } case (expr_move(?a, ?b)) { - vt(v).visit_expr(b, e, v); - vt(v).visit_expr(a, e, v); + v.visit_expr(b, e, v); + v.visit_expr(a, e, v); } case (expr_swap(?a, ?b)) { - vt(v).visit_expr(a, e, v); - vt(v).visit_expr(b, e, v); + v.visit_expr(a, e, v); + v.visit_expr(b, e, v); } case (expr_assign_op(_, ?a, ?b)) { - vt(v).visit_expr(b, e, v); - vt(v).visit_expr(a, e, v); + v.visit_expr(b, e, v); + v.visit_expr(a, e, v); } case (expr_send(?a, ?b)) { - vt(v).visit_expr(a, e, v); - vt(v).visit_expr(b, e, v); + v.visit_expr(a, e, v); + v.visit_expr(b, e, v); } case (expr_recv(?a, ?b)) { - vt(v).visit_expr(a, e, v); - vt(v).visit_expr(b, e, v); + v.visit_expr(a, e, v); + v.visit_expr(b, e, v); } - case (expr_field(?x, _)) { vt(v).visit_expr(x, e, v); } + case (expr_field(?x, _)) { v.visit_expr(x, e, v); } case (expr_index(?a, ?b)) { - vt(v).visit_expr(a, e, v); - vt(v).visit_expr(b, e, v); + v.visit_expr(a, e, v); + v.visit_expr(b, e, v); } case (expr_path(?p)) { - for (@ty tp in p.node.types) { vt(v).visit_ty(tp, e, v); } + for (@ty tp in p.node.types) { v.visit_ty(tp, e, v); } } case (expr_ext(_, _, _, ?expansion)) { - vt(v).visit_expr(expansion, e, v); + v.visit_expr(expansion, e, v); } case (expr_fail(?eo)) { visit_expr_opt(eo, e, v); @@ -365,38 +362,39 @@ fn visit_expr[E](&@expr ex, &E e, &vt[E] v) { case (expr_cont) { } case (expr_ret(?eo)) { visit_expr_opt(eo, e, v); } case (expr_put(?eo)) { visit_expr_opt(eo, e, v); } - case (expr_be(?x)) { vt(v).visit_expr(x, e, v); } - case (expr_log(_, ?x)) { vt(v).visit_expr(x, e, v); } - case (expr_check(_, ?x)) { vt(v).visit_expr(x, e, v); } - case (expr_assert(?x)) { vt(v).visit_expr(x, e, v); } + case (expr_be(?x)) { v.visit_expr(x, e, v); } + case (expr_log(_, ?x)) { v.visit_expr(x, e, v); } + case (expr_check(_, ?x)) { v.visit_expr(x, e, v); } + case (expr_assert(?x)) { v.visit_expr(x, e, v); } case (expr_port(_)) { } - case (expr_chan(?x)) { vt(v).visit_expr(x, e, v); } + case (expr_chan(?x)) { v.visit_expr(x, e, v); } case (expr_anon_obj(?anon_obj, _)) { alt (anon_obj.fields) { case (none) { } case (some(?fields)) { for (anon_obj_field f in fields) { - vt(v).visit_ty(f.ty, e, v); - vt(v).visit_expr(f.expr, e, v); + v.visit_ty(f.ty, e, v); + v.visit_expr(f.expr, e, v); } } } alt (anon_obj.with_obj) { case (none) { } - case (some(?ex)) { vt(v).visit_expr(ex, e, v); } + case (some(?ex)) { v.visit_expr(ex, e, v); } } for (@method m in anon_obj.methods) { - vt(v).visit_fn(m.node.meth, ~[], m.span, some(m.node.ident), - m.node.id, e, v); + v.visit_fn(m.node.meth, ~[], m.span, some(m.node.ident), + m.node.id, e, v); } } } } fn visit_arm[E](&arm a, &E e, &vt[E] v) { - for (@pat p in a.pats) { vt(v).visit_pat(p, e, v); } - vt(v).visit_block(a.block, e, v); + for (@pat p in a.pats) { v.visit_pat(p, e, v); } + v.visit_block(a.block, e, v); } + // Local Variables: // mode: rust // fill-column: 78;