rust/src/comp/front/fold.rs

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_name_value(?id,?s)) {
                     meta_name_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=fld.fold_mod(c.module),
            attrs=map(fold_attribute, c.attrs),
            config=map(fold_meta_item, c.config));
}

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,?attrs)) { 
            cdir_src_mod(fld.fold_ident(id), fname, attrs)
                }
        case(cdir_dir_mod(?id,?fname,?cds,?attrs)) {
            cdir_dir_mod(fld.fold_ident(id),fname,
                         map(fld.fold_crate_directive, cds), attrs)
                }
        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_ternary(?cond, ?tr, ?fl)) {
            expr_ternary(fld.fold_expr(cond),
                         fld.fold_expr(tr),
                         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_fn(?f)) {
            expr_fn(fld.fold_fn(f))
                }
        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_swap(?el, ?er)) {
            expr_swap(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(?m, ?e)) { expr_check(m, fld.fold_expr(e)) }
        case (expr_if_check(?cond, ?tr, ?fl)) {
            expr_if_check(fld.fold_expr(cond), fld.fold_block(tr), 
                          option::map(fld.fold_expr, fl))
                }
        case (expr_port(?ot)) { 
            expr_port(alt(ot) {
                    case (option::some(?t)) { option::some(fld.fold_ty(t)) }
                    case (option::none) { option::none }
                })
                }
        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:
//