Move visit to newtype-style nominal type

This makes getting the function fields out of the visitor less
cumbersome and more efficient (no take/drop).

1 files changed, 110 insertions, 112 deletions

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;