Add AST fold.

src/comp/front/fold.rs

@@ -0,0 +1,689 @@
+import util::common::span;
+import ast::*;
+
+import std::vec;
+import std::option;
+import vec::map;
+
+export ast_fold_precursor;
+export ast_fold;
+export default_ast_fold;
+export make_fold;
+export dummy_out;
+
+type ast_fold = @mutable a_f;
+
+// We may eventually want to be able to fold over type parameters, too
+
+type ast_fold_precursor = 
+    rec(fn (&crate_ c, ast_fold) -> crate_                fold_crate,
+        fn (&crate_directive_ cd, ast_fold) -> crate_directive_ 
+                                                 fold_crate_directive,
+        fn (&view_item_ i, ast_fold) -> view_item_        fold_view_item,
+        fn (&@native_item i, ast_fold) -> @native_item    fold_native_item,
+        fn (&@item i, ast_fold) -> @item                  fold_item,
+        //unlike the others, item_ is non-trivial
+        fn (&item_ i, ast_fold) -> item_        fold_item_underscore,
+        fn (&method_ m, ast_fold) -> method_              fold_method,
+        fn (&block_ b, ast_fold) -> block_                fold_block,
+        fn (&stmt_ s, ast_fold) -> stmt_                  fold_stmt,
+        fn (&arm a, ast_fold) -> arm                      fold_arm,
+        fn (&pat_ p, ast_fold) -> pat_                    fold_pat,
+        fn (&decl_ d, ast_fold) -> decl_                  fold_decl,
+        fn (&expr_ e, ast_fold) -> expr_                  fold_expr,
+        fn (&ty_ t, ast_fold) -> ty_                      fold_ty,
+        fn (&constr_ c, ast_fold) -> constr_              fold_constr,
+        fn (&_fn f, ast_fold) -> _fn                      fold_fn,
+        fn (&_mod m, ast_fold) -> _mod                    fold_mod,
+        fn (&native_mod, ast_fold) -> native_mod          fold_native_mod,
+        fn (&variant_, ast_fold) -> variant_              fold_variant,
+        fn (&ident, ast_fold) -> ident                    fold_ident,
+        fn (&path_, ast_fold) -> path_                    fold_path,
+        fn (&local_, ast_fold) -> local_                  fold_local
+        );
+
+type a_f =
+    rec(fn (&crate c) -> crate                        fold_crate,
+        fn (&@crate_directive cd) -> @crate_directive fold_crate_directive,
+        fn (&@view_item i) -> @view_item              fold_view_item,
+        fn (&@native_item i) -> @native_item          fold_native_item,
+        fn (&@item i) -> @item                        fold_item,
+        fn (&item_ i) -> item_                        fold_item_underscore,
+        fn (&@method m) -> @method                    fold_method,
+        fn (&block b) -> block                        fold_block,
+        fn (&@stmt s) -> @stmt                        fold_stmt,
+        fn (&arm a) -> arm                            fold_arm,
+        fn (&@pat p) -> @pat                          fold_pat,
+        fn (&@decl d) -> @decl                        fold_decl,
+        fn (&@expr e) -> @expr                        fold_expr,
+        fn (&@ty t) -> @ty                            fold_ty,
+        fn (&@constr c) -> @constr                    fold_constr,
+        fn (&_fn f) -> _fn                            fold_fn,
+        fn (&_mod m) -> _mod                          fold_mod,
+        fn (&native_mod) -> native_mod                fold_native_mod,
+        fn (&variant) -> variant                      fold_variant,
+        fn (&ident) -> ident                          fold_ident,
+        fn (&path) -> path                            fold_path,
+        fn (&@local) -> @local                        fold_local
+        );
+
+//fn nf_dummy[T](&T node) -> T { fail; }
+fn nf_crate_dummy(&crate c) -> crate { fail; }
+fn nf_crate_directive_dummy(&@crate_directive c) 
+    -> @crate_directive { fail; }
+fn nf_view_item_dummy(&@view_item v) -> @view_item { fail; } 
+fn nf_native_item_dummy(&@native_item n) -> @native_item { fail; } 
+fn nf_item_dummy(&@item i) -> @item { fail; } 
+fn nf_item_underscore_dummy(&item_ i) -> item_ { fail; } 
+fn nf_method_dummy(&@method m) -> @method { fail; } 
+fn nf_block_dummy(&block b) -> block { fail; } 
+fn nf_stmt_dummy(&@stmt s) -> @stmt { fail; } 
+fn nf_arm_dummy(&arm a) -> arm { fail; } 
+fn nf_pat_dummy(&@pat p) -> @pat { fail; } 
+fn nf_decl_dummy(&@decl d) -> @decl { fail; } 
+fn nf_expr_dummy(&@expr e) -> @expr { fail; } 
+fn nf_ty_dummy(&@ty t) -> @ty { fail; } 
+fn nf_constr_dummy(&@constr c) -> @constr { fail; } 
+fn nf_fn_dummy(&_fn f) -> _fn { fail; } 
+fn nf_mod_dummy(&_mod m) -> _mod { fail; } 
+fn nf_native_mod_dummy(&native_mod n) -> native_mod { fail; } 
+fn nf_variant_dummy(&variant v) -> variant { fail; } 
+fn nf_ident_dummy(&ident i) -> ident { fail; } 
+fn nf_path_dummy(&path p) -> path { fail; } 
+fn nf_obj_field_dummy(&obj_field o) -> obj_field { fail; }
+fn nf_local_dummy(&@local o) -> @local { fail; }
+
+/* some little folds that probably aren't useful to have in ast_fold itself*/
+
+//used in noop_fold_item and noop_fold_crate and noop_fold_crate_directive
+fn fold_meta_item_(&@meta_item mi, ast_fold fld) -> @meta_item {
+    ret @rec(node=
+             alt (mi.node) {
+                 case (meta_word(?id)) { meta_word(fld.fold_ident(id)) }
+                 case (meta_list(?id, ?mis)) {
+                     auto fold_meta_item = bind fold_meta_item_(_,fld);
+                     meta_list(id, map(fold_meta_item, mis))
+                 }
+                 case (meta_key_value(?id,?s)) {
+                     meta_key_value(fld.fold_ident(id),s)
+                 }
+             },
+             span=mi.span);
+}
+//used in noop_fold_item and noop_fold_crate
+fn fold_attribute_(&attribute at, fn(&@meta_item) -> @meta_item fmi) 
+    -> attribute {
+    ret rec(node=rec(style=at.node.style,
+                     value=*fmi(@at.node.value)),
+            span=at.span);
+}
+//used in noop_fold_native_item and noop_fold_fn
+fn fold_arg_(&arg a, ast_fold fld) -> arg {
+    ret rec(mode=a.mode, ty=fld.fold_ty(a.ty), 
+            ident=fld.fold_ident(a.ident), id=a.id);
+}
+
+
+
+
+fn noop_fold_crate(&crate_ c, ast_fold fld) -> crate_ {
+    auto fold_meta_item = bind fold_meta_item_(_,fld);
+    auto fold_attribute = bind fold_attribute_(_,fold_meta_item);
+
+    ret rec(directives=map(fld.fold_crate_directive, c.directives),
+            module=c.module, attrs=map(fold_attribute, c.attrs));
+}
+
+fn noop_fold_crate_directive(&crate_directive_ cd, ast_fold fld) 
+    -> crate_directive_ {
+    auto fold_meta_item = bind fold_meta_item_(_,fld);
+    ret alt(cd) {
+        case(cdir_expr(?e)) { cdir_expr(fld.fold_expr(e)) }
+        case(cdir_let(?id, ?e, ?cds)) {
+            cdir_let(fld.fold_ident(id), fld.fold_expr(e),
+                     map(fld.fold_crate_directive, cds))
+                }
+        case(cdir_src_mod(?id,?fname)) { 
+            cdir_src_mod(fld.fold_ident(id), fname)
+                }
+        case(cdir_dir_mod(?id,?fname,?cds)) {
+            cdir_dir_mod(fld.fold_ident(id),fname,
+                         map(fld.fold_crate_directive, cds))
+                }
+        case(cdir_view_item(?vi)) { 
+            cdir_view_item(fld.fold_view_item(vi))
+                }
+        case(cdir_syntax(_)) { cd }
+        case(cdir_auth(_,_)) { cd }
+    }
+}
+
+fn noop_fold_view_item(&view_item_ vi, ast_fold fld) -> view_item_ {
+    ret vi;
+}
+
+
+fn noop_fold_native_item(&@native_item ni, ast_fold fld) -> @native_item {
+    auto fold_arg = bind fold_arg_(_, fld);
+
+    ret @rec(ident=fld.fold_ident(ni.ident),
+             node=alt (ni.node) {
+                 case (native_item_ty) { native_item_ty }
+                 case (native_item_fn(?st, ?fdec, ?typms)) {
+                     native_item_fn(st, 
+                                    rec(inputs=map(fold_arg, fdec.inputs),
+                                        output=fld.fold_ty(fdec.output),
+                                        purity=fdec.purity, cf=fdec.cf,
+                                        constraints=map(fld.fold_constr,
+                                                        fdec.constraints)),
+                                    typms)
+                 }
+             },
+             id=ni.id,
+             span=ni.span);
+}
+
+fn noop_fold_item(&@item i, ast_fold fld) -> @item {
+    auto fold_meta_item = bind fold_meta_item_(_,fld);
+    auto fold_attribute = bind fold_attribute_(_,fold_meta_item);
+
+    ret @rec(ident=fld.fold_ident(i.ident),
+             attrs=map(fold_attribute,i.attrs),
+             id=i.id, node=fld.fold_item_underscore(i.node),
+             span=i.span);
+}
+
+fn noop_fold_item_underscore(&item_ i, ast_fold fld) -> item_ {
+    fn fold_obj_field_(&obj_field of, ast_fold fld) -> obj_field {
+        ret rec(mut=of.mut, ty=fld.fold_ty(of.ty), 
+                ident=fld.fold_ident(of.ident), id=of.id);
+    }
+    auto fold_obj_field = bind fold_obj_field_(_,fld);
+
+    ret alt(i) {
+        case (item_const(?t, ?e)) {
+            item_const(fld.fold_ty(t), fld.fold_expr(e))
+        }
+        case (item_fn(?f, ?typms)) {
+            item_fn(fld.fold_fn(f), typms)
+        }
+        case (item_mod(?m)) { item_mod(fld.fold_mod(m)) }
+        case (item_native_mod(?nm)) {
+            item_native_mod(fld.fold_native_mod(nm))
+                }
+        case (item_ty(?t, ?typms)) {
+            item_ty(fld.fold_ty(t), typms)
+                }
+        case (item_tag(?variants, ?typms)) {
+            item_tag(map(fld.fold_variant, variants), typms)
+                }
+        case (item_obj(?o, ?typms, ?d)) {
+            item_obj(rec(fields=map(fold_obj_field,o.fields),
+                         methods=map(fld.fold_method,o.methods),
+                         dtor=option::map(fld.fold_method,o.dtor)),
+                     typms, d)
+                }
+    };
+}
+
+fn noop_fold_method(&method_ m, ast_fold fld) -> method_ {
+    ret rec(ident=fld.fold_ident(m.ident),
+            meth=fld.fold_fn(m.meth), id=m.id); 
+}
+
+
+fn noop_fold_block(&block_ b, ast_fold fld) -> block_ {
+    ret rec(stmts=map(fld.fold_stmt, b.stmts),
+            expr=option::map(fld.fold_expr, b.expr), id=b.id);
+}
+
+fn noop_fold_stmt(&stmt_ s, ast_fold fld) -> stmt_ {
+    ret alt(s) {
+        case (stmt_decl(?d, ?nid)) { stmt_decl(fld.fold_decl(d), nid) }
+        case (stmt_expr(?e, ?nid)) { stmt_expr(fld.fold_expr(e), nid) }
+        case (stmt_crate_directive(?cd)) {
+                stmt_crate_directive(fld.fold_crate_directive(cd))
+                    }
+    };
+}
+
+fn noop_fold_arm(&arm a, ast_fold fld) -> arm {
+    ret rec(pat=fld.fold_pat(a.pat), block=fld.fold_block(a.block));
+}
+
+fn noop_fold_pat(&pat_ p, ast_fold fld) -> pat_ {
+    ret alt (p) {
+        case (pat_wild(_)) { p }
+        case (pat_bind(?id, ?d)) { pat_bind(fld.fold_ident(id), d)}
+        case (pat_lit(_, _)) { p }
+        case (pat_tag(?pth, ?pats, ?nid)) {
+            pat_tag(fld.fold_path(pth), map(fld.fold_pat, pats), nid)
+                }
+    };
+}
+
+fn noop_fold_decl(&decl_ d, ast_fold fld) -> decl_ {
+    ret alt (d) {
+        // local really doesn't need its own fold...
+        case (decl_local(?l)) {
+            decl_local(fld.fold_local(l))
+        }
+        case (decl_item(?it)) { decl_item(fld.fold_item(it)) }
+    }
+}
+
+fn noop_fold_expr(&expr_ e, ast_fold fld) -> expr_ {
+    fn fold_elt_(&elt elt, ast_fold fld) -> elt {
+        ret rec(mut=elt.mut, expr=fld.fold_expr(elt.expr));
+    }
+    auto fold_elt = bind fold_elt_(_,fld);
+    fn fold_field_(&field field, ast_fold fld) -> field {
+        ret rec(node=rec(mut=field.node.mut,
+                         ident=fld.fold_ident(field.node.ident),
+                         expr=fld.fold_expr(field.node.expr)),
+                span=field.span);
+    }
+    auto fold_field = bind fold_field_(_,fld);
+    fn fold_anon_obj_(&anon_obj ao, ast_fold fld) -> anon_obj {
+        fn fold_anon_obj_field_(&anon_obj_field aof, ast_fold fld) 
+            -> anon_obj_field {
+            ret rec(mut=aof.mut, ty=fld.fold_ty(aof.ty), 
+                    expr=fld.fold_expr(aof.expr),
+                    ident=fld.fold_ident(aof.ident), id=aof.id);
+        }
+        auto fold_anon_obj_field = bind fold_anon_obj_field_(_,fld);
+
+        ret rec(fields=alt(ao.fields) {
+                    case (option::none[vec[anon_obj_field]]) { ao.fields }
+                    case (option::some[vec[anon_obj_field]](?v)) {
+                        option::some[vec[anon_obj_field]]
+                            (map(fold_anon_obj_field, v))
+                    }},
+                methods=map(fld.fold_method, ao.methods),
+                with_obj=option::map(fld.fold_expr, ao.with_obj))
+    }
+    auto fold_anon_obj = bind fold_anon_obj_(_,fld);
+    
+
+    ret alt (e) {
+        case (expr_vec(?exprs, ?mut, ?seq_kind)) {
+            expr_vec(map(fld.fold_expr, exprs), mut, seq_kind)
+                }
+        case (expr_tup(?elts)) {
+            expr_tup(map(fold_elt, elts))
+                }
+        case (expr_rec(?fields, ?maybe_expr)) {
+            expr_rec(map(fold_field, fields),
+                     option::map(fld.fold_expr, maybe_expr))
+                }
+        case (expr_call(?f, ?args)) {
+            expr_call(fld.fold_expr(f), map(fld.fold_expr, args))
+                }
+        case (expr_self_method(?id)) {
+            expr_self_method(fld.fold_ident(id))
+                }
+        case (expr_bind(?f, ?args)) {
+            auto opt_map_se = bind option::map(fld.fold_expr,_);
+            expr_bind(fld.fold_expr(f), map(opt_map_se, args))
+                }
+        case (expr_spawn(?spawn_dom, ?name, ?f, ?args)) {
+            expr_spawn(spawn_dom, name, fld.fold_expr(f), 
+                       map(fld.fold_expr, args))
+                }
+        case (expr_binary(?binop, ?lhs, ?rhs)) {
+            expr_binary(binop, fld.fold_expr(lhs), fld.fold_expr(rhs))
+                }
+        case (expr_unary(?binop, ?ohs)) {
+            expr_unary(binop, fld.fold_expr(ohs))
+                }
+        case (expr_lit(_)) { e }
+        case (expr_cast(?expr, ?ty)) {
+            expr_cast(fld.fold_expr(expr), ty)
+        }
+        case (expr_if(?cond, ?tr, ?fl)) {
+            expr_if(fld.fold_expr(cond), fld.fold_block(tr), 
+                    option::map(fld.fold_expr, fl))
+                }
+        case (expr_while(?cond, ?body)) {
+            expr_while(fld.fold_expr(cond), fld.fold_block(body))
+                }
+        case (expr_for(?decl, ?expr, ?block)) {
+            expr_for(fld.fold_local(decl), fld.fold_expr(expr), 
+                     fld.fold_block(block))
+                }
+        case (expr_for_each(?decl, ?expr, ?block)) {
+            expr_for_each(fld.fold_local(decl), fld.fold_expr(expr), 
+                          fld.fold_block(block))
+                }
+        case (expr_do_while(?block, ?expr)) {
+            expr_do_while(fld.fold_block(block), fld.fold_expr(expr))
+                }
+        case (expr_alt(?expr, ?arms)) {
+            expr_alt(fld.fold_expr(expr), map(fld.fold_arm, arms))
+                }
+        case (expr_block(?block)) {
+            expr_block(fld.fold_block(block))
+                }
+        case (expr_move(?el, ?er)) {
+            expr_move(fld.fold_expr(el), fld.fold_expr(er))
+                }
+        case (expr_assign(?el, ?er)) {
+            expr_assign(fld.fold_expr(el), fld.fold_expr(er))
+                }
+        case (expr_assign_op(?op, ?el, ?er)) {
+            expr_assign_op(op, fld.fold_expr(el), fld.fold_expr(er))
+                }
+        case (expr_send(?el, ?er)) {
+            expr_send(fld.fold_expr(el), fld.fold_expr(er))
+                }
+        case (expr_recv(?el, ?er)) {
+            expr_recv(fld.fold_expr(el), fld.fold_expr(er))
+                }
+        case (expr_field(?el, ?id)) {
+            expr_field(fld.fold_expr(el), fld.fold_ident(id))
+                }
+        case (expr_index(?el, ?er)) {
+            expr_index(fld.fold_expr(el), fld.fold_expr(er))
+                }
+        case (expr_path(?pth)) {
+            expr_path(fld.fold_path(pth))
+                }
+        case (expr_ext(?pth, ?args, ?body, ?expanded)) {
+            expr_ext(fld.fold_path(pth), map(fld.fold_expr, args),
+                     body, fld.fold_expr(expanded))
+                }
+        case (expr_fail(_)) { e }
+        case (expr_break()) { e }
+        case (expr_cont()) { e }
+        case (expr_ret(?e)) { 
+            expr_ret(option::map(fld.fold_expr, e))
+                }
+        case (expr_put(?e)) { 
+            expr_put(option::map(fld.fold_expr, e))
+                }
+        case (expr_be(?e)) { expr_be(fld.fold_expr(e)) }
+        case (expr_log(?lv, ?e)) { expr_log(lv, fld.fold_expr(e)) }
+        case (expr_assert(?e)) { expr_assert(fld.fold_expr(e)) }
+        case (expr_check(?e)) { expr_check(fld.fold_expr(e)) }
+        case (expr_port()) { e }
+        case (expr_chan(?e)) { expr_chan(fld.fold_expr(e)) }
+        case (expr_anon_obj(?ao, ?typms, ?odis)) {
+            expr_anon_obj(fold_anon_obj(ao), typms, odis)
+                }
+    }
+}
+
+fn noop_fold_ty(&ty_ t, ast_fold fld) -> ty_ {
+    //drop in ty::fold_ty here if necessary
+    ret t;
+}
+
+fn noop_fold_constr(&constr_ c, ast_fold fld) -> constr_ {
+    ret rec(path=fld.fold_path(c.path), args=c.args, id=c.id);
+}
+
+// functions just don't get spans, for some reason
+fn noop_fold_fn(&_fn f, ast_fold fld) -> _fn {
+    auto fold_arg = bind fold_arg_(_, fld);
+
+    ret rec(decl= rec(inputs=map(fold_arg, f.decl.inputs),
+                      output=fld.fold_ty(f.decl.output),
+                      purity=f.decl.purity,
+                      cf=f.decl.cf,
+                      constraints=map(fld.fold_constr, f.decl.constraints)),
+            proto = f.proto,
+            body = fld.fold_block(f.body));
+}
+
+// ...nor do modules
+fn noop_fold_mod(&_mod m, ast_fold fld) -> _mod {
+    ret rec(view_items=map(fld.fold_view_item, m.view_items),
+            items=map(fld.fold_item, m.items));
+}
+
+fn noop_fold_native_mod(&native_mod nm, ast_fold fld) -> native_mod {
+    ret rec(native_name=nm.native_name,
+            abi=nm.abi,
+            view_items=map(fld.fold_view_item, nm.view_items),
+            items=map(fld.fold_native_item, nm.items))
+}
+
+fn noop_fold_variant(&variant_ v, ast_fold fld) -> variant_ {
+    fn fold_variant_arg_(&variant_arg va, ast_fold fld) -> variant_arg {
+        ret rec(ty=fld.fold_ty(va.ty), id=va.id);
+    }
+    auto fold_variant_arg = bind fold_variant_arg_(_,fld);
+    ret rec(name=v.name,
+            args=map(fold_variant_arg, v.args),
+            id=v.id);
+}
+
+fn noop_fold_ident(&ident i, ast_fold fld) -> ident {
+    ret i;
+}
+
+fn noop_fold_path(&path_ p, ast_fold fld) -> path_ {
+    ret rec(idents=map(fld.fold_ident, p.idents),
+            types=map(fld.fold_ty, p.types));
+}
+
+fn noop_fold_local(&local_ l, ast_fold fld) -> local_ {
+    ret rec(ty=option::map(fld.fold_ty,l.ty),
+            infer=l.infer,
+            ident=fld.fold_ident(l.ident),
+            init=alt (l.init) {
+                case (option::none[initializer]) { l.init }
+                case (option::some[initializer](?init)) {
+                    option::some[initializer]
+                    (rec(op=init.op, 
+                         expr=fld.fold_expr(init.expr)))
+                }
+            },
+            id=l.id);
+}
+
+
+fn default_ast_fold() -> @ast_fold_precursor {
+    ret @rec(fold_crate = noop_fold_crate,
+             fold_crate_directive = noop_fold_crate_directive,
+             fold_view_item = noop_fold_view_item,
+             fold_native_item = noop_fold_native_item,
+             fold_item = noop_fold_item,
+             fold_item_underscore = noop_fold_item_underscore,
+             fold_method = noop_fold_method,
+             fold_block = noop_fold_block,
+             fold_stmt = noop_fold_stmt,
+             fold_arm = noop_fold_arm,
+             fold_pat = noop_fold_pat,
+             fold_decl = noop_fold_decl,
+             fold_expr = noop_fold_expr,
+             fold_ty = noop_fold_ty,
+             fold_constr = noop_fold_constr,
+             fold_fn = noop_fold_fn,
+             fold_mod = noop_fold_mod,
+             fold_native_mod = noop_fold_native_mod,
+             fold_variant = noop_fold_variant,
+             fold_ident = noop_fold_ident,
+             fold_path = noop_fold_path,
+             fold_local = noop_fold_local);
+}
+
+fn dummy_out(ast_fold a) {
+    *a = rec(fold_crate = nf_crate_dummy,
+                     fold_crate_directive = nf_crate_directive_dummy,
+                     fold_view_item = nf_view_item_dummy,
+                     fold_native_item = nf_native_item_dummy,
+                     fold_item = nf_item_dummy,
+                     fold_item_underscore = nf_item_underscore_dummy,
+                     fold_method = nf_method_dummy,
+                     fold_block = nf_block_dummy,
+                     fold_stmt = nf_stmt_dummy,
+                     fold_arm = nf_arm_dummy,
+                     fold_pat = nf_pat_dummy,
+                     fold_decl = nf_decl_dummy,
+                     fold_expr = nf_expr_dummy,
+                     fold_ty = nf_ty_dummy,
+                     fold_constr = nf_constr_dummy,
+                     fold_fn = nf_fn_dummy,
+                     fold_mod = nf_mod_dummy,
+                     fold_native_mod = nf_native_mod_dummy,
+                     fold_variant = nf_variant_dummy,
+                     fold_ident = nf_ident_dummy,
+                     fold_path = nf_path_dummy,
+                     fold_local = nf_local_dummy);
+}
+
+
+fn make_fold(&ast_fold_precursor afp) -> ast_fold {
+    let ast_fold result = 
+        @mutable rec(fold_crate = nf_crate_dummy,
+                     fold_crate_directive = nf_crate_directive_dummy,
+                     fold_view_item = nf_view_item_dummy,
+                     fold_native_item = nf_native_item_dummy,
+                     fold_item = nf_item_dummy,
+                     fold_item_underscore = nf_item_underscore_dummy,
+                     fold_method = nf_method_dummy,
+                     fold_block = nf_block_dummy,
+                     fold_stmt = nf_stmt_dummy,
+                     fold_arm = nf_arm_dummy,
+                     fold_pat = nf_pat_dummy,
+                     fold_decl = nf_decl_dummy,
+                     fold_expr = nf_expr_dummy,
+                     fold_ty = nf_ty_dummy,
+                     fold_constr = nf_constr_dummy,
+                     fold_fn = nf_fn_dummy,
+                     fold_mod = nf_mod_dummy,
+                     fold_native_mod = nf_native_mod_dummy,
+                     fold_variant = nf_variant_dummy,
+                     fold_ident = nf_ident_dummy,
+                     fold_path = nf_path_dummy,
+                     fold_local = nf_local_dummy);
+
+    /* naturally, a macro to write these would be nice */
+    fn f_crate(&ast_fold_precursor afp, ast_fold f, &crate c) -> crate {
+        ret rec(node=afp.fold_crate(c.node, f),
+                span=c.span);
+    }
+    fn f_crate_directive(&ast_fold_precursor afp, ast_fold f, 
+                         &@crate_directive c) -> @crate_directive {
+        ret @rec(node=afp.fold_crate_directive(c.node, f),
+                 span=c.span);
+    }
+    fn f_view_item(&ast_fold_precursor afp, ast_fold f, &@view_item x)
+        -> @view_item {
+        ret @rec(node=afp.fold_view_item(x.node, f), span=x.span);
+    }
+    fn f_native_item(&ast_fold_precursor afp, ast_fold f, &@native_item x)
+        -> @native_item {
+        ret afp.fold_native_item(x, f);
+    }
+    fn f_item(&ast_fold_precursor afp, ast_fold f, &@item i) -> @item {
+        ret afp.fold_item(i, f);
+    }
+    fn f_item_underscore(&ast_fold_precursor afp, ast_fold f, &item_ i) ->
+        item_ {
+        ret afp.fold_item_underscore(i, f);
+    }
+    fn f_method(&ast_fold_precursor afp, ast_fold f, &@method x) -> @method {
+        ret @rec(node=afp.fold_method(x.node, f), span=x.span);
+    }
+    fn f_block(&ast_fold_precursor afp, ast_fold f, &block x) -> block {
+        ret rec(node=afp.fold_block(x.node, f), span=x.span);
+    }
+    fn f_stmt(&ast_fold_precursor afp, ast_fold f, &@stmt x) -> @stmt {
+        ret @rec(node=afp.fold_stmt(x.node, f), span=x.span);
+    }
+    fn f_arm(&ast_fold_precursor afp, ast_fold f, &arm x) -> arm {
+        ret afp.fold_arm(x, f);
+    }
+    fn f_pat(&ast_fold_precursor afp, ast_fold f, &@pat x) -> @pat {
+        ret @rec(node=afp.fold_pat(x.node, f), span=x.span);
+    }
+    fn f_decl(&ast_fold_precursor afp, ast_fold f, &@decl x) -> @decl {
+        ret @rec(node=afp.fold_decl(x.node, f), span=x.span);
+    }
+    fn f_expr(&ast_fold_precursor afp, ast_fold f, &@expr x) -> @expr {
+        ret @rec(id=x.id, node=afp.fold_expr(x.node, f), span=x.span);
+    }
+    fn f_ty(&ast_fold_precursor afp, ast_fold f, &@ty x) -> @ty {
+        ret @rec(node=afp.fold_ty(x.node, f), span=x.span);
+    }
+    fn f_constr(&ast_fold_precursor afp, ast_fold f, &@constr x) -> @constr {
+        ret @rec(node=afp.fold_constr(x.node, f), span=x.span);
+    }
+    fn f_fn(&ast_fold_precursor afp, ast_fold f, &_fn x) -> _fn {
+        ret afp.fold_fn(x, f);
+    }    
+    fn f_mod(&ast_fold_precursor afp, ast_fold f, &_mod x) -> _mod {
+        ret afp.fold_mod(x, f);
+    }
+    fn f_native_mod(&ast_fold_precursor afp, ast_fold f, &native_mod x) -> 
+        native_mod {
+        ret afp.fold_native_mod(x, f);
+    }    
+    fn f_variant(&ast_fold_precursor afp, ast_fold f, &variant x)
+        -> variant {
+        ret rec(node=afp.fold_variant(x.node, f), span=x.span);
+    }
+    fn f_ident(&ast_fold_precursor afp, ast_fold f, &ident x) -> ident {
+        ret afp.fold_ident(x, f);
+    }
+    fn f_path(&ast_fold_precursor afp, ast_fold f, &path x) -> path {
+        ret rec(node=afp.fold_path(x.node, f), span=x.span);
+    }
+    fn f_local(&ast_fold_precursor afp, ast_fold f, &@local x) -> @local {
+        ret @rec(node=afp.fold_local(x.node, f), span=x.span);
+    }
+
+    *result = rec(fold_crate = bind f_crate(afp,result,_),
+                  fold_crate_directive = bind f_crate_directive(afp,result,_),
+                  fold_view_item = bind f_view_item(afp,result,_),
+                  fold_native_item = bind f_native_item(afp,result,_),
+                  fold_item = bind f_item(afp,result,_),
+                  fold_item_underscore = bind f_item_underscore(afp,result,_),
+                  fold_method = bind f_method(afp,result,_),
+                  fold_block = bind f_block(afp,result,_),
+                  fold_stmt = bind f_stmt(afp,result,_),
+                  fold_arm = bind f_arm(afp, result, _),
+                  fold_pat = bind f_pat(afp,result,_),
+                  fold_decl = bind f_decl(afp,result,_),
+                  fold_expr = bind f_expr(afp,result,_),
+                  fold_ty = bind f_ty(afp,result,_),
+                  fold_constr = bind f_constr(afp,result,_),
+                  fold_fn = bind f_fn(afp,result,_),
+                  fold_mod = bind f_mod(afp,result,_),
+                  fold_native_mod = bind f_native_mod(afp,result,_),
+                  fold_variant = bind f_variant(afp,result,_),
+                  fold_ident = bind f_ident(afp,result,_),
+                  fold_path = bind f_path(afp,result,_),
+                  fold_local = bind f_local(afp,result,_));
+    ret result;
+    /*
+    ret rec(fold_crate = noop_fold_crate,
+          fold_crate_directive = noop_fold_crate_drective,
+          fold_view_item = noop_fold_view_item,
+          fold_native_item = noop_fold_native_item,
+          fold_item = noop_fold_item,
+          fold_method = noop_fold_method,
+          fold_block = noop_fold_block,
+          fold_stmt = noop_fold_stmt,
+          fold_arm = noop_fold_arm,
+          fold_pat = noop_fold_pat,
+          fold_decl = noop_fold_decl,
+          fold_expr = noop_fold_expr,
+          fold_ty = noop_fold_ty,
+          fold_constr = noop_fold_constr,
+          fold_fn = noop_fold_fn);*/
+}
+
+
+//
+// Local Variables:
+// mode: rust
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End:
+//

src/comp/rustc.rc

@@ -48,6 +48,7 @@ mod front {
     mod ext;
     mod extfmt;
     mod extenv;
+    mod fold;
     mod codemap;
     mod lexer;
     mod parser;