Alias-ify fold and its users, remove another 85kb.

4 files changed, 371 insertions, 351 deletions

diff --git a/src/comp/middle/fold.rs b/src/comp/middle/fold.rs
index ace45c2f..3afa9ef6 100644
--- a/src/comp/middle/fold.rs
+++ b/src/comp/middle/fold.rs
@@ -39,7 +39,7 @@ type ast_fold[ENV] =
     @rec
     (
      // Path fold.
-     (fn(&ENV e, &span sp, ast.path_ p) -> path)  fold_path,
+     (fn(&ENV e, &span sp, &ast.path_ p) -> path) fold_path,
 
      // Type folds.
      (fn(&ENV e, &span sp) -> @ty)                fold_ty_nil,
@@ -53,246 +53,252 @@ type ast_fold[ENV] =
      (fn(&ENV e, &span sp, &mt tm) -> @ty)        fold_ty_box,
      (fn(&ENV e, &span sp, &mt tm) -> @ty)        fold_ty_vec,
 
-     (fn(&ENV e, &span sp, vec[mt] elts) -> @ty)  fold_ty_tup,
+     (fn(&ENV e, &span sp, &vec[mt] elts) -> @ty) fold_ty_tup,
 
      (fn(&ENV e, &span sp,
-         vec[ast.ty_field] elts) -> @ty)          fold_ty_rec,
+         &vec[ast.ty_field] elts) -> @ty)         fold_ty_rec,
 
      (fn(&ENV e, &span sp,
-         vec[ast.ty_method] meths) -> @ty)        fold_ty_obj,
+         &vec[ast.ty_method] meths) -> @ty)       fold_ty_obj,
 
      (fn(&ENV e, &span sp,
          ast.proto proto,
-         vec[rec(ast.mode mode, @ty ty)] inputs,
-         @ty output) -> @ty)                      fold_ty_fn,
+         &vec[rec(ast.mode mode, @ty ty)] inputs,
+         &@ty output) -> @ty)                     fold_ty_fn,
 
-     (fn(&ENV e, &span sp, ast.path p,
+     (fn(&ENV e, &span sp, &ast.path p,
          &Option.t[def] d) -> @ty)                fold_ty_path,
 
-     (fn(&ENV e, &span sp, @ty t) -> @ty)         fold_ty_chan,
-     (fn(&ENV e, &span sp, @ty t) -> @ty)         fold_ty_port,
+     (fn(&ENV e, &span sp, &@ty t) -> @ty)        fold_ty_chan,
+     (fn(&ENV e, &span sp, &@ty t) -> @ty)        fold_ty_port,
 
      // Expr folds.
      (fn(&ENV e, &span sp,
-         vec[@expr] es, ast.mutability mut,
-         ann a) -> @expr)                         fold_expr_vec,
+         &vec[@expr] es, ast.mutability mut,
+         &ann a) -> @expr)                        fold_expr_vec,
 
      (fn(&ENV e, &span sp,
-         vec[ast.elt] es, ann a) -> @expr)        fold_expr_tup,
+         &vec[ast.elt] es, &ann a) -> @expr)      fold_expr_tup,
 
      (fn(&ENV e, &span sp,
-         vec[ast.field] fields,
-         Option.t[@expr] base, ann a) -> @expr)   fold_expr_rec,
+         &vec[ast.field] fields,
+         &Option.t[@expr] base, &ann a) -> @expr) fold_expr_rec,
 
      (fn(&ENV e, &span sp,
-         @expr f, vec[@expr] args,
-         ann a) -> @expr)                         fold_expr_call,
+         &@expr f, &vec[@expr] args,
+         &ann a) -> @expr)                        fold_expr_call,
 
      (fn(&ENV e, &span sp,
-         ident id, ann a) -> @expr)               fold_expr_self_method,
+         &ident id, &ann a) -> @expr)             fold_expr_self_method,
 
      (fn(&ENV e, &span sp,
-         @expr f, vec[Option.t[@expr]] args,
-         ann a) -> @expr)                         fold_expr_bind,
+         &@expr f, &vec[Option.t[@expr]] args,
+         &ann a) -> @expr)                        fold_expr_bind,
 
      (fn(&ENV e, &span sp,
-         ast.spawn_dom dom, Option.t[str] name,
-         @expr f, vec[@expr] args,
-         ann a) -> @expr)                         fold_expr_spawn,
+         ast.spawn_dom dom, &Option.t[str] name,
+         &@expr f, &vec[@expr] args,
+         &ann a) -> @expr)                        fold_expr_spawn,
 
      (fn(&ENV e, &span sp,
          ast.binop,
-         @expr lhs, @expr rhs,
-         ann a) -> @expr)                         fold_expr_binary,
+         &@expr lhs, &@expr rhs,
+         &ann a) -> @expr)                        fold_expr_binary,
 
      (fn(&ENV e, &span sp,
-         ast.unop, @expr e,
-         ann a) -> @expr)                         fold_expr_unary,
+         ast.unop, &@expr e,
+         &ann a) -> @expr)                        fold_expr_unary,
 
      (fn(&ENV e, &span sp,
-         @ast.lit, ann a) -> @expr)               fold_expr_lit,
+         &@ast.lit, &ann a) -> @expr)             fold_expr_lit,
 
      (fn(&ENV e, &span sp,
-         @ast.expr e, @ast.ty ty,
-         ann a) -> @expr)                         fold_expr_cast,
+         &@ast.expr e, &@ast.ty ty,
+         &ann a) -> @expr)                        fold_expr_cast,
 
      (fn(&ENV e, &span sp,
-         @expr cond, &block thn,
+         &@expr cond, &block thn,
          &Option.t[@expr] els,
-         ann a) -> @expr)                         fold_expr_if,
+         &ann a) -> @expr)                        fold_expr_if,
 
      (fn(&ENV e, &span sp,
-         @decl decl, @expr seq, &block body,
-         ann a) -> @expr)                         fold_expr_for,
+         &@decl decl, &@expr seq, &block body,
+         &ann a) -> @expr)                        fold_expr_for,
 
      (fn(&ENV e, &span sp,
-         @decl decl, @expr seq, &block body,
-         ann a) -> @expr)                         fold_expr_for_each,
+         &@decl decl, &@expr seq, &block body,
+         &ann a) -> @expr)                        fold_expr_for_each,
 
      (fn(&ENV e, &span sp,
-         @expr cond, &block body,
-         ann a) -> @expr)                         fold_expr_while,
+         &@expr cond, &block body,
+         &ann a) -> @expr)                        fold_expr_while,
 
      (fn(&ENV e, &span sp,
-         &block body, @expr cond,
-         ann a) -> @expr)                         fold_expr_do_while,
+         &block body, &@expr cond,
+         &ann a) -> @expr)                        fold_expr_do_while,
 
      (fn(&ENV e, &span sp,
-         @expr e, vec[arm] arms,
-         ann a) -> @expr)                         fold_expr_alt,
+         &@expr e, &vec[arm] arms,
+         &ann a) -> @expr)                        fold_expr_alt,
 
      (fn(&ENV e, &span sp,
-         &block blk, ann a) -> @expr)             fold_expr_block,
+         &block blk, &ann a) -> @expr)            fold_expr_block,
 
      (fn(&ENV e, &span sp,
-         @expr lhs, @expr rhs,
-         ann a) -> @expr)                         fold_expr_assign,
+         &@expr lhs, &@expr rhs,
+         &ann a) -> @expr)                        fold_expr_assign,
 
      (fn(&ENV e, &span sp,
          ast.binop,
-         @expr lhs, @expr rhs,
-         ann a) -> @expr)                         fold_expr_assign_op,
+         &@expr lhs, &@expr rhs,
+         &ann a) -> @expr)                        fold_expr_assign_op,
 
      (fn(&ENV e, &span sp,
-         @expr lhs, @expr rhs, ann a) -> @expr)   fold_expr_send,
+         &@expr lhs, &@expr rhs,
+         &ann a) -> @expr)                        fold_expr_send,
 
      (fn(&ENV e, &span sp,
-         @expr lhs, @expr rhs, ann a) -> @expr)   fold_expr_recv,
+         &@expr lhs, &@expr rhs,
+         &ann a) -> @expr)                        fold_expr_recv,
 
      (fn(&ENV e, &span sp,
-         @expr e, ident i,
-         ann a) -> @expr)                         fold_expr_field,
+         &@expr e, &ident i,
+         &ann a) -> @expr)                        fold_expr_field,
 
      (fn(&ENV e, &span sp,
-         @expr e, @expr ix,
-         ann a) -> @expr)                         fold_expr_index,
+         &@expr e, &@expr ix,
+         &ann a) -> @expr)                        fold_expr_index,
 
      (fn(&ENV e, &span sp,
          &path p,
          &Option.t[def] d,
-         ann a) -> @expr)                         fold_expr_path,
+         &ann a) -> @expr)                        fold_expr_path,
 
      (fn(&ENV e, &span sp,
-         &path p, vec[@expr] args,
-         Option.t[str] body,
-         @expr expanded,
-         ann a) -> @expr)                         fold_expr_ext,
+         &path p, &vec[@expr] args,
+         &Option.t[str] body,
+         &@expr expanded,
+         &ann a) -> @expr)                        fold_expr_ext,
 
-     (fn(&ENV e, &span sp, ann a) -> @expr)       fold_expr_fail,
+     (fn(&ENV e, &span sp, &ann a) -> @expr)      fold_expr_fail,
 
-     (fn(&ENV e, &span sp, ann a) -> @expr)       fold_expr_break,
+     (fn(&ENV e, &span sp, &ann a) -> @expr)      fold_expr_break,
 
-     (fn(&ENV e, &span sp, ann a) -> @expr)       fold_expr_cont,
+     (fn(&ENV e, &span sp, &ann a) -> @expr)      fold_expr_cont,
 
      (fn(&ENV e, &span sp,
-         &Option.t[@expr] rv, ann a) -> @expr)    fold_expr_ret,
+         &Option.t[@expr] rv, &ann a) -> @expr)   fold_expr_ret,
 
      (fn(&ENV e, &span sp,
-         &Option.t[@expr] rv, ann a) -> @expr)    fold_expr_put,
+         &Option.t[@expr] rv, &ann a) -> @expr)   fold_expr_put,
 
      (fn(&ENV e, &span sp,
-         @expr e, ann a) -> @expr)                fold_expr_be,
+         &@expr e, &ann a) -> @expr)              fold_expr_be,
 
      (fn(&ENV e, &span sp, int lvl,
-         @expr e, ann a) -> @expr)                fold_expr_log,
+         &@expr e, &ann a) -> @expr)              fold_expr_log,
 
      (fn(&ENV e, &span sp,
-         @expr e, ann a) -> @expr)                fold_expr_check,
+         &@expr e, &ann a) -> @expr)              fold_expr_check,
 
      (fn(&ENV e, &span sp,
-         @expr e, ann a) -> @expr)                fold_expr_assert,
+         &@expr e, &ann a) -> @expr)              fold_expr_assert,
 
      (fn(&ENV e, &span sp,
-         ann a) -> @expr)                         fold_expr_port,
+         &ann a) -> @expr)                        fold_expr_port,
 
      (fn(&ENV e, &span sp,
-         @expr e, ann a) -> @expr)                fold_expr_chan,
+         &@expr e, &ann a) -> @expr)              fold_expr_chan,
 
 
      // Decl folds.
      (fn(&ENV e, &span sp,
-         @ast.local local) -> @decl)              fold_decl_local,
+         &@ast.local local) -> @decl)             fold_decl_local,
 
      (fn(&ENV e, &span sp,
-         @item item) -> @decl)                    fold_decl_item,
+         &@item item) -> @decl)                   fold_decl_item,
 
 
      // Pat folds.
      (fn(&ENV e, &span sp,
-         ann a) -> @pat)                          fold_pat_wild,
+         &ann a) -> @pat)                         fold_pat_wild,
 
      (fn(&ENV e, &span sp,
-         @ast.lit lit, ann a) -> @pat)            fold_pat_lit,
+         &@ast.lit lit, &ann a) -> @pat)          fold_pat_lit,
 
      (fn(&ENV e, &span sp,
-         ident i, def_id did, ann a) -> @pat)     fold_pat_bind,
+         &ident i, &def_id did, &ann a) -> @pat)  fold_pat_bind,
 
      (fn(&ENV e, &span sp,
-         path p, vec[@pat] args,
-         Option.t[ast.variant_def] d,
-         ann a) -> @pat)                          fold_pat_tag,
+         &path p, &vec[@pat] args,
+         &Option.t[ast.variant_def] d,
+         &ann a) -> @pat)                         fold_pat_tag,
 
 
      // Stmt folds.
      (fn(&ENV e, &span sp,
-         @decl decl, ann a)
+         &@decl decl, &ann a)
       -> @stmt)                                   fold_stmt_decl,
 
      (fn(&ENV e, &span sp,
-         @expr e, ann a)
+         &@expr e, &ann a)
       -> @stmt)                                   fold_stmt_expr,
 
      // Item folds.
-     (fn(&ENV e, &span sp, ident ident,
-         @ty t, @expr e,
-         def_id id, ann a) -> @item)              fold_item_const,
+     (fn(&ENV e, &span sp, &ident ident,
+         &@ty t, &@expr e,
+         &def_id id, &ann a) -> @item)            fold_item_const,
 
-     (fn(&ENV e, &span sp, ident ident,
+     (fn(&ENV e, &span sp, &ident ident,
          &ast._fn f,
-         vec[ast.ty_param] ty_params,
-         def_id id, ann a) -> @item)              fold_item_fn,
+         &vec[ast.ty_param] ty_params,
+         &def_id id, &ann a) -> @item)            fold_item_fn,
 
-     (fn(&ENV e, &span sp, ident ident,
-         Option.t[str] link_name,
+     (fn(&ENV e, &span sp, &ident ident,
+         &Option.t[str] link_name,
          &ast.fn_decl decl,
-         vec[ast.ty_param] ty_params,
-         def_id id, ann a) -> @native_item)       fold_native_item_fn,
+         &vec[ast.ty_param] ty_params,
+         &def_id id, &ann a) -> @native_item)     fold_native_item_fn,
 
-     (fn(&ENV e, &span sp, ident ident,
-         &ast._mod m, def_id id) -> @item)        fold_item_mod,
+     (fn(&ENV e, &span sp, &ident ident,
+         &ast._mod m, &def_id id) -> @item)       fold_item_mod,
 
-     (fn(&ENV e, &span sp, ident ident,
-         &ast.native_mod m, def_id id) -> @item)  fold_item_native_mod,
+     (fn(&ENV e, &span sp, &ident ident,
+         &ast.native_mod m, &def_id id) -> @item) fold_item_native_mod,
 
-     (fn(&ENV e, &span sp, ident ident,
-         @ty t, vec[ast.ty_param] ty_params,
-         def_id id, ann a) -> @item)              fold_item_ty,
+     (fn(&ENV e, &span sp, &ident ident,
+         &@ty t, &vec[ast.ty_param] ty_params,
+         &def_id id, &ann a) -> @item)            fold_item_ty,
 
-     (fn(&ENV e, &span sp, ident ident,
-         def_id id) -> @native_item)              fold_native_item_ty,
+     (fn(&ENV e, &span sp, &ident ident,
+         &def_id id) -> @native_item)             fold_native_item_ty,
 
-     (fn(&ENV e, &span sp, ident ident,
-         vec[ast.variant] variants,
-         vec[ast.ty_param] ty_params,
-         def_id id, ann a) -> @item)              fold_item_tag,
+     (fn(&ENV e, &span sp, &ident ident,
+         &vec[ast.variant] variants,
+         &vec[ast.ty_param] ty_params,
+         &def_id id, &ann a) -> @item)            fold_item_tag,
 
-     (fn(&ENV e, &span sp, ident ident,
+     (fn(&ENV e, &span sp, &ident ident,
          &ast._obj ob,
-         vec[ast.ty_param] ty_params,
-         ast.obj_def_ids odid, ann a) -> @item)   fold_item_obj,
+         &vec[ast.ty_param] ty_params,
+         &ast.obj_def_ids odid, &ann a) -> @item) fold_item_obj,
 
      // View Item folds.
-     (fn(&ENV e, &span sp, ident ident,
-         vec[@meta_item] meta_items,
-         def_id id, Option.t[int]) -> @view_item) fold_view_item_use,
+     (fn(&ENV e, &span sp, &ident ident,
+         &vec[@meta_item] meta_items,
+         &def_id id,
+         &Option.t[int]) -> @view_item)           fold_view_item_use,
 
-     (fn(&ENV e, &span sp, ident i, vec[ident] idents,
-         def_id id, Option.t[def]) -> @view_item) fold_view_item_import,
+     (fn(&ENV e, &span sp, &ident i,
+         &vec[ident] idents,
+         &def_id id,
+         &Option.t[def]) -> @view_item)           fold_view_item_import,
 
-     (fn(&ENV e, &span sp, ident i) -> @view_item) fold_view_item_export,
+     (fn(&ENV e, &span sp,
+         &ident i) -> @view_item)                 fold_view_item_export,
 
      // Annotation folds.
-     (fn(&ENV e, ann a) -> ann)                   fold_ann,
+     (fn(&ENV e, &ann a) -> ann)                  fold_ann,
 
      // Additional nodes.
 
@@ -301,35 +307,36 @@ type ast_fold[ENV] =
          &block body) -> ast._fn)                 fold_fn,
 
      (fn(&ENV e,
-         vec[arg] inputs,
-         @ty output,
-         purity p) -> ast.fn_decl)                fold_fn_decl,
+         &vec[arg] inputs,
+         &@ty output,
+         &purity p) -> ast.fn_decl)               fold_fn_decl,
 
      (fn(&ENV e, &ast._mod m) -> ast._mod)        fold_mod,
 
      (fn(&ENV e, &ast.native_mod m) -> ast.native_mod) fold_native_mod,
 
      (fn(&ENV e, &span sp,
-         vec[@ast.crate_directive] cdirs,
+         &vec[@ast.crate_directive] cdirs,
          &ast._mod m) -> @ast.crate)              fold_crate,
 
      (fn(&ENV e,
-         vec[ast.obj_field] fields,
-         vec[@ast.method] methods,
-         Option.t[@ast.method] dtor) -> ast._obj) fold_obj,
+         &vec[ast.obj_field] fields,
+         &vec[@ast.method] methods,
+         &Option.t[@ast.method] dtor)
+      -> ast._obj)                                fold_obj,
 
      // Env updates.
-     (fn(&ENV e, @ast.crate c) -> ENV) update_env_for_crate,
-     (fn(&ENV e, @item i) -> ENV) update_env_for_item,
-     (fn(&ENV e, @native_item i) -> ENV) update_env_for_native_item,
-     (fn(&ENV e, @view_item i) -> ENV) update_env_for_view_item,
+     (fn(&ENV e, &@ast.crate c) -> ENV) update_env_for_crate,
+     (fn(&ENV e, &@item i) -> ENV) update_env_for_item,
+     (fn(&ENV e, &@native_item i) -> ENV) update_env_for_native_item,
+     (fn(&ENV e, &@view_item i) -> ENV) update_env_for_view_item,
      (fn(&ENV e, &block b) -> ENV) update_env_for_block,
-     (fn(&ENV e, @stmt s) -> ENV) update_env_for_stmt,
-     (fn(&ENV e, @decl i) -> ENV) update_env_for_decl,
-     (fn(&ENV e, @pat p) -> ENV) update_env_for_pat,
+     (fn(&ENV e, &@stmt s) -> ENV) update_env_for_stmt,
+     (fn(&ENV e, &@decl i) -> ENV) update_env_for_decl,
+     (fn(&ENV e, &@pat p) -> ENV) update_env_for_pat,
      (fn(&ENV e, &arm a) -> ENV) update_env_for_arm,
-     (fn(&ENV e, @expr x) -> ENV) update_env_for_expr,
-     (fn(&ENV e, @ty t) -> ENV) update_env_for_ty,
+     (fn(&ENV e, &@expr x) -> ENV) update_env_for_expr,
+     (fn(&ENV e, &@ty t) -> ENV) update_env_for_ty,
 
      // Traversal control.
      (fn(&ENV v) -> bool) keep_going
@@ -338,7 +345,7 @@ type ast_fold[ENV] =
 
 //// Fold drivers.
 
-fn fold_path[ENV](&ENV env, ast_fold[ENV] fld, &path p) -> path {
+fn fold_path[ENV](&ENV env, &ast_fold[ENV] fld, &path p) -> path {
     let vec[@ast.ty] tys_ = vec();
     for (@ast.ty t in p.node.types) {
         Vec.push[@ast.ty](tys_, fold_ty(env, fld, t));
@@ -347,7 +354,7 @@ fn fold_path[ENV](&ENV env, ast_fold[ENV] fld, &path p) -> path {
     ret fld.fold_path(env, p.span, p_);
 }
 
-fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty {
+fn fold_ty[ENV](&ENV env, &ast_fold[ENV] fld, &@ty t) -> @ty {
     let ENV env_ = fld.update_env_for_ty(env, t);
 
     if (!fld.keep_going(env_)) {
@@ -434,10 +441,10 @@ fn fold_ty[ENV](&ENV env, ast_fold[ENV] fld, @ty t) -> @ty {
     }
 }
 
-fn fold_ty_fn[ENV](&ENV env, ast_fold[ENV] fld, &span sp,
+fn fold_ty_fn[ENV](&ENV env, &ast_fold[ENV] fld, &span sp,
                    ast.proto proto,
-                   vec[rec(ast.mode mode, @ty ty)] inputs,
-                   @ty output) -> @ty {
+                   &vec[rec(ast.mode mode, @ty ty)] inputs,
+                   &@ty output) -> @ty {
     auto output_ = fold_ty(env, fld, output);
     let vec[rec(ast.mode mode, @ty ty)] inputs_ = vec();
     for (rec(ast.mode mode, @ty ty) input in inputs) {
@@ -448,7 +455,7 @@ fn fold_ty_fn[ENV](&ENV env, ast_fold[ENV] fld, &span sp,
     ret fld.fold_ty_fn(env, sp, proto, inputs_, output_);
 }
 
-fn fold_decl[ENV](&ENV env, ast_fold[ENV] fld, @decl d) -> @decl {
+fn fold_decl[ENV](&ENV env, &ast_fold[ENV] fld, &@decl d) -> @decl {
     let ENV env_ = fld.update_env_for_decl(env, d);
 
     if (!fld.keep_going(env_)) {
@@ -487,7 +494,7 @@ fn fold_decl[ENV](&ENV env, ast_fold[ENV] fld, @decl d) -> @decl {
     fail;
 }
 
-fn fold_pat[ENV](&ENV env, ast_fold[ENV] fld, @ast.pat p) -> @ast.pat {
+fn fold_pat[ENV](&ENV env, &ast_fold[ENV] fld, &@ast.pat p) -> @ast.pat {
     let ENV env_ = fld.update_env_for_pat(env, p);
 
     if (!fld.keep_going(env_)) {
@@ -515,7 +522,8 @@ fn fold_pat[ENV](&ENV env, ast_fold[ENV] fld, @ast.pat p) -> @ast.pat {
     }
 }
 
-fn fold_exprs[ENV](&ENV env, ast_fold[ENV] fld, vec[@expr] es) -> vec[@expr] {
+fn fold_exprs[ENV](&ENV env, &ast_fold[ENV] fld,
+                   &vec[@expr] es) -> vec[@expr] {
     let vec[@expr] exprs = vec();
     for (@expr e in es) {
         Vec.push[@expr](exprs, fold_expr(env, fld, e));
@@ -523,16 +531,16 @@ fn fold_exprs[ENV](&ENV env, ast_fold[ENV] fld, vec[@expr] es) -> vec[@expr] {
     ret exprs;
 }
 
-fn fold_tup_elt[ENV](&ENV env, ast_fold[ENV] fld, &ast.elt e) -> ast.elt {
+fn fold_tup_elt[ENV](&ENV env, &ast_fold[ENV] fld, &ast.elt e) -> ast.elt {
     ret rec(expr=fold_expr(env, fld, e.expr) with e);
 }
 
-fn fold_rec_field[ENV](&ENV env, ast_fold[ENV] fld, &ast.field f)
+fn fold_rec_field[ENV](&ENV env, &ast_fold[ENV] fld, &ast.field f)
     -> ast.field {
     ret rec(expr=fold_expr(env, fld, f.expr) with f);
 }
 
-fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
+fn fold_expr[ENV](&ENV env, &ast_fold[ENV] fld, &@expr e) -> @expr {
 
     let ENV env_ = fld.update_env_for_expr(env, e);
 
@@ -829,7 +837,7 @@ fn fold_expr[ENV](&ENV env, ast_fold[ENV] fld, &@expr e) -> @expr {
 }
 
 
-fn fold_stmt[ENV](&ENV env, ast_fold[ENV] fld, &@stmt s) -> @stmt {
+fn fold_stmt[ENV](&ENV env, &ast_fold[ENV] fld, &@stmt s) -> @stmt {
 
     let ENV env_ = fld.update_env_for_stmt(env, s);
 
@@ -853,7 +861,7 @@ fn fold_stmt[ENV](&ENV env, ast_fold[ENV] fld, &@stmt s) -> @stmt {
     fail;
 }
 
-fn fold_block[ENV](&ENV env, ast_fold[ENV] fld, &block blk) -> block {
+fn fold_block[ENV](&ENV env, &ast_fold[ENV] fld, &block blk) -> block {
 
     auto index = new_str_hash[ast.block_index_entry]();
     let ENV env_ = fld.update_env_for_block(env, blk);
@@ -879,23 +887,23 @@ fn fold_block[ENV](&ENV env, ast_fold[ENV] fld, &block blk) -> block {
         }
     }
 
-    auto aa = fld.fold_ann(env, blk.node.a); 
+    auto aa = fld.fold_ann(env, blk.node.a);
     ret respan(blk.span, rec(stmts=stmts, expr=expr, index=index, a=aa));
 }
 
-fn fold_arm[ENV](&ENV env, ast_fold[ENV] fld, &arm a) -> arm {
+fn fold_arm[ENV](&ENV env, &ast_fold[ENV] fld, &arm a) -> arm {
     let ENV env_ = fld.update_env_for_arm(env, a);
     auto ppat = fold_pat(env_, fld, a.pat);
     auto bblock = fold_block(env_, fld, a.block);
     ret rec(pat=ppat, block=bblock, index=a.index);
 }
 
-fn fold_arg[ENV](&ENV env, ast_fold[ENV] fld, &arg a) -> arg {
+fn fold_arg[ENV](&ENV env, &ast_fold[ENV] fld, &arg a) -> arg {
     auto ty = fold_ty(env, fld, a.ty);
     ret rec(ty=ty with a);
 }
 
-fn fold_fn_decl[ENV](&ENV env, ast_fold[ENV] fld,
+fn fold_fn_decl[ENV](&ENV env, &ast_fold[ENV] fld,
                      &ast.fn_decl decl) -> ast.fn_decl {
     let vec[ast.arg] inputs = vec();
     for (ast.arg a in decl.inputs) {
@@ -905,7 +913,7 @@ fn fold_fn_decl[ENV](&ENV env, ast_fold[ENV] fld,
     ret fld.fold_fn_decl(env, inputs, output, decl.purity);
 }
 
-fn fold_fn[ENV](&ENV env, ast_fold[ENV] fld, &ast._fn f) -> ast._fn {
+fn fold_fn[ENV](&ENV env, &ast_fold[ENV] fld, &ast._fn f) -> ast._fn {
     auto decl = fold_fn_decl(env, fld, f.decl);
 
     auto body = fold_block[ENV](env, fld, f.body);
@@ -914,21 +922,21 @@ fn fold_fn[ENV](&ENV env, ast_fold[ENV] fld, &ast._fn f) -> ast._fn {
 }
 
 
-fn fold_obj_field[ENV](&ENV env, ast_fold[ENV] fld,
+fn fold_obj_field[ENV](&ENV env, &ast_fold[ENV] fld,
                        &ast.obj_field f) -> ast.obj_field {
     auto ty = fold_ty(env, fld, f.ty);
     ret rec(ty=ty with f);
 }
 
 
-fn fold_method[ENV](&ENV env, ast_fold[ENV] fld,
-                    @ast.method m) -> @ast.method {
+fn fold_method[ENV](&ENV env, &ast_fold[ENV] fld,
+                    &@ast.method m) -> @ast.method {
     auto meth = fold_fn(env, fld, m.node.meth);
     ret @rec(node=rec(meth=meth with m.node) with *m);
 }
 
 
-fn fold_obj[ENV](&ENV env, ast_fold[ENV] fld, &ast._obj ob) -> ast._obj {
+fn fold_obj[ENV](&ENV env, &ast_fold[ENV] fld, &ast._obj ob) -> ast._obj {
 
     let vec[ast.obj_field] fields = vec();
     let vec[@ast.method] meths = vec();
@@ -959,7 +967,7 @@ fn fold_obj[ENV](&ENV env, ast_fold[ENV] fld, &ast._obj ob) -> ast._obj {
     ret fld.fold_obj(env, fields, meths, dtor);
 }
 
-fn fold_view_item[ENV](&ENV env, ast_fold[ENV] fld, @view_item vi)
+fn fold_view_item[ENV](&ENV env, &ast_fold[ENV] fld, &@view_item vi)
     -> @view_item {
 
     let ENV env_ = fld.update_env_for_view_item(env, vi);
@@ -987,7 +995,7 @@ fn fold_view_item[ENV](&ENV env, ast_fold[ENV] fld, @view_item vi)
     fail;
 }
 
-fn fold_item[ENV](&ENV env, ast_fold[ENV] fld, @item i) -> @item {
+fn fold_item[ENV](&ENV env, &ast_fold[ENV] fld, &@item i) -> @item {
 
     let ENV env_ = fld.update_env_for_item(env, i);
 
@@ -1049,7 +1057,7 @@ fn fold_item[ENV](&ENV env, ast_fold[ENV] fld, @item i) -> @item {
     fail;
 }
 
-fn fold_mod[ENV](&ENV e, ast_fold[ENV] fld, &ast._mod m) -> ast._mod {
+fn fold_mod[ENV](&ENV e, &ast_fold[ENV] fld, &ast._mod m) -> ast._mod {
 
     let vec[@view_item] view_items = vec();
     let vec[@item] items = vec();
@@ -1070,8 +1078,8 @@ fn fold_mod[ENV](&ENV e, ast_fold[ENV] fld, &ast._mod m) -> ast._mod {
     ret fld.fold_mod(e, rec(view_items=view_items, items=items, index=index));
 }
 
-fn fold_native_item[ENV](&ENV env, ast_fold[ENV] fld,
-                         @native_item i) -> @native_item {
+fn fold_native_item[ENV](&ENV env, &ast_fold[ENV] fld,
+                         &@native_item i) -> @native_item {
     let ENV env_ = fld.update_env_for_native_item(env, i);
 
     if (!fld.keep_going(env_)) {
@@ -1090,7 +1098,7 @@ fn fold_native_item[ENV](&ENV env, ast_fold[ENV] fld,
     }
 }
 
-fn fold_native_mod[ENV](&ENV e, ast_fold[ENV] fld,
+fn fold_native_mod[ENV](&ENV e, &ast_fold[ENV] fld,
                         &ast.native_mod m) -> ast.native_mod {
     let vec[@view_item] view_items = vec();
     let vec[@native_item] items = vec();
@@ -1114,7 +1122,8 @@ fn fold_native_mod[ENV](&ENV e, ast_fold[ENV] fld,
                                    index=index));
 }
 
-fn fold_crate[ENV](&ENV env, ast_fold[ENV] fld, @ast.crate c) -> @ast.crate {
+fn fold_crate[ENV](&ENV env, &ast_fold[ENV] fld,
+                   &@ast.crate c) -> @ast.crate {
     // FIXME: possibly fold the directives so you process any expressions
     // within them? Not clear. After front/eval.rs, nothing else should look
     // at crate directives.
@@ -1132,7 +1141,7 @@ fn respan[T](&span sp, &T t) -> spanned[T] {
 
 // Path identity.
 
-fn identity_fold_path[ENV](&ENV env, &span sp, ast.path_ p) -> path {
+fn identity_fold_path[ENV](&ENV env, &span sp, &ast.path_ p) -> path {
     ret respan(sp, p);
 }
 
@@ -1180,359 +1189,368 @@ fn identity_fold_ty_vec[ENV](&ENV env, &span sp, &mt tm) -> @ty {
 }
 
 fn identity_fold_ty_tup[ENV](&ENV env, &span sp,
-                             vec[mt] elts) -> @ty {
+                             &vec[mt] elts) -> @ty {
     ret @respan(sp, ast.ty_tup(elts));
 }
 
 fn identity_fold_ty_rec[ENV](&ENV env, &span sp,
-                             vec[ast.ty_field] elts) -> @ty {
+                             &vec[ast.ty_field] elts) -> @ty {
     ret @respan(sp, ast.ty_rec(elts));
 }
 
 fn identity_fold_ty_obj[ENV](&ENV env, &span sp,
-                             vec[ast.ty_method] meths) -> @ty {
+                             &vec[ast.ty_method] meths) -> @ty {
     ret @respan(sp, ast.ty_obj(meths));
 }
 
 fn identity_fold_ty_fn[ENV](&ENV env, &span sp,
                             ast.proto proto,
-                            vec[rec(ast.mode mode, @ty ty)] inputs,
-                            @ty output) -> @ty {
+                            &vec[rec(ast.mode mode, @ty ty)] inputs,
+                            &@ty output) -> @ty {
     ret @respan(sp, ast.ty_fn(proto, inputs, output));
 }
 
-fn identity_fold_ty_path[ENV](&ENV env, &span sp, ast.path p,
-                        &Option.t[def] d) -> @ty {
+fn identity_fold_ty_path[ENV](&ENV env, &span sp, &ast.path p,
+                              &Option.t[def] d) -> @ty {
     ret @respan(sp, ast.ty_path(p, d));
 }
 
-fn identity_fold_ty_chan[ENV](&ENV env, &span sp, @ty t) -> @ty {
+fn identity_fold_ty_chan[ENV](&ENV env, &span sp, &@ty t) -> @ty {
     ret @respan(sp, ast.ty_chan(t));
 }
 
-fn identity_fold_ty_port[ENV](&ENV env, &span sp, @ty t) -> @ty {
+fn identity_fold_ty_port[ENV](&ENV env, &span sp, &@ty t) -> @ty {
     ret @respan(sp, ast.ty_port(t));
 }
 
 // Expr identities.
 
-fn identity_fold_expr_vec[ENV](&ENV env, &span sp, vec[@expr] es,
-                               ast.mutability mut, ann a) -> @expr {
+fn identity_fold_expr_vec[ENV](&ENV env, &span sp, &vec[@expr] es,
+                               ast.mutability mut, &ann a) -> @expr {
     ret @respan(sp, ast.expr_vec(es, mut, a));
 }
 
 fn identity_fold_expr_tup[ENV](&ENV env, &span sp,
-                               vec[ast.elt] es, ann a) -> @expr {
+                               &vec[ast.elt] es, &ann a) -> @expr {
     ret @respan(sp, ast.expr_tup(es, a));
 }
 
 fn identity_fold_expr_rec[ENV](&ENV env, &span sp,
-                               vec[ast.field] fields,
-                               Option.t[@expr] base, ann a) -> @expr {
+                               &vec[ast.field] fields,
+                               &Option.t[@expr] base, &ann a) -> @expr {
     ret @respan(sp, ast.expr_rec(fields, base, a));
 }
 
-fn identity_fold_expr_call[ENV](&ENV env, &span sp, @expr f,
-                                vec[@expr] args, ann a) -> @expr {
+fn identity_fold_expr_call[ENV](&ENV env, &span sp, &@expr f,
+                                &vec[@expr] args, &ann a) -> @expr {
     ret @respan(sp, ast.expr_call(f, args, a));
 }
 
-fn identity_fold_expr_self_method[ENV](&ENV env, &span sp, ident id,
-                                       ann a) -> @expr {
+fn identity_fold_expr_self_method[ENV](&ENV env, &span sp, &ident id,
+                                       &ann a) -> @expr {
     ret @respan(sp, ast.expr_self_method(id, a));
 }
 
-fn identity_fold_expr_bind[ENV](&ENV env, &span sp, @expr f,
-                                vec[Option.t[@expr]] args_opt, ann a)
+fn identity_fold_expr_bind[ENV](&ENV env, &span sp, &@expr f,
+                                &vec[Option.t[@expr]] args_opt, &ann a)
         -> @expr {
     ret @respan(sp, ast.expr_bind(f, args_opt, a));
 }
 
 fn identity_fold_expr_spawn[ENV](&ENV env, &span sp,
-                                 ast.spawn_dom dom, Option.t[str] name,
-                                 @expr f, vec[@expr] args, ann a) -> @expr {
+                                 ast.spawn_dom dom, &Option.t[str] name,
+                                 &@expr f, &vec[@expr] args,
+                                 &ann a) -> @expr {
     ret @respan(sp, ast.expr_spawn(dom, name, f, args, a));
 }
 
 fn identity_fold_expr_binary[ENV](&ENV env, &span sp, ast.binop b,
-                                  @expr lhs, @expr rhs,
-                                  ann a) -> @expr {
+                                  &@expr lhs, &@expr rhs,
+                                  &ann a) -> @expr {
     ret @respan(sp, ast.expr_binary(b, lhs, rhs, a));
 }
 
 fn identity_fold_expr_unary[ENV](&ENV env, &span sp,
-                                 ast.unop u, @expr e, ann a)
+                                 ast.unop u, &@expr e, &ann a)
         -> @expr {
     ret @respan(sp, ast.expr_unary(u, e, a));
 }
 
-fn identity_fold_expr_lit[ENV](&ENV env, &span sp, @ast.lit lit,
-                               ann a) -> @expr {
+fn identity_fold_expr_lit[ENV](&ENV env, &span sp, &@ast.lit lit,
+                               &ann a) -> @expr {
     ret @respan(sp, ast.expr_lit(lit, a));
 }
 
-fn identity_fold_expr_cast[ENV](&ENV env, &span sp, @ast.expr e,
-                                @ast.ty t, ann a) -> @expr {
+fn identity_fold_expr_cast[ENV](&ENV env, &span sp, &@ast.expr e,
+                                &@ast.ty t, &ann a) -> @expr {
     ret @respan(sp, ast.expr_cast(e, t, a));
 }
 
 fn identity_fold_expr_if[ENV](&ENV env, &span sp,
-                              @expr cond, &block thn,
-                              &Option.t[@expr] els, ann a) -> @expr {
+                              &@expr cond, &block thn,
+                              &Option.t[@expr] els, &ann a) -> @expr {
     ret @respan(sp, ast.expr_if(cond, thn, els, a));
 }
 
 fn identity_fold_expr_for[ENV](&ENV env, &span sp,
-                               @decl d, @expr seq,
-                               &block body, ann a) -> @expr {
+                               &@decl d, &@expr seq,
+                               &block body, &ann a) -> @expr {
     ret @respan(sp, ast.expr_for(d, seq, body, a));
 }
 
 fn identity_fold_expr_for_each[ENV](&ENV env, &span sp,
-                                    @decl d, @expr seq,
-                                    &block body, ann a) -> @expr {
+                                    &@decl d, &@expr seq,
+                                    &block body, &ann a) -> @expr {
     ret @respan(sp, ast.expr_for_each(d, seq, body, a));
 }
 
 fn identity_fold_expr_while[ENV](&ENV env, &span sp,
-                                 @expr cond, &block body, ann a) -> @expr {
+                                 &@expr cond, &block body, &ann a) -> @expr {
     ret @respan(sp, ast.expr_while(cond, body, a));
 }
 
 fn identity_fold_expr_do_while[ENV](&ENV env, &span sp,
-                                    &block body, @expr cond, ann a) -> @expr {
+                                    &block body, &@expr cond,
+                                    &ann a) -> @expr {
     ret @respan(sp, ast.expr_do_while(body, cond, a));
 }
 
 fn identity_fold_expr_alt[ENV](&ENV env, &span sp,
-                               @expr e, vec[arm] arms, ann a) -> @expr {
+                               &@expr e, &vec[arm] arms,
+                               &ann a) -> @expr {
     ret @respan(sp, ast.expr_alt(e, arms, a));
 }
 
 fn identity_fold_expr_block[ENV](&ENV env, &span sp, &block blk,
-                                 ann a) -> @expr {
+                                 &ann a) -> @expr {
     ret @respan(sp, ast.expr_block(blk, a));
 }
 
 fn identity_fold_expr_assign[ENV](&ENV env, &span sp,
-                                  @expr lhs, @expr rhs, ann a)
+                                  &@expr lhs, &@expr rhs, &ann a)
         -> @expr {
     ret @respan(sp, ast.expr_assign(lhs, rhs, a));
 }
 
 fn identity_fold_expr_assign_op[ENV](&ENV env, &span sp, ast.binop op,
-                                     @expr lhs, @expr rhs, ann a)
+                                     &@expr lhs, &@expr rhs, &ann a)
         -> @expr {
     ret @respan(sp, ast.expr_assign_op(op, lhs, rhs, a));
 }
 
 fn identity_fold_expr_send[ENV](&ENV e, &span sp,
-                                @expr lhs, @expr rhs, ann a) -> @expr {
+                                &@expr lhs, &@expr rhs, &ann a) -> @expr {
     ret @respan(sp, ast.expr_send(lhs, rhs, a));
 }
 
 fn identity_fold_expr_recv[ENV](&ENV e, &span sp,
-                                @expr lhs, @expr rhs, ann a) -> @expr {
+                                &@expr lhs, &@expr rhs, &ann a) -> @expr {
     ret @respan(sp, ast.expr_recv(lhs, rhs, a));
 }
 
 fn identity_fold_expr_field[ENV](&ENV env, &span sp,
-                                 @expr e, ident i, ann a) -> @expr {
+                                 &@expr e, &ident i, &ann a) -> @expr {
     ret @respan(sp, ast.expr_field(e, i, a));
 }
 
 fn identity_fold_expr_index[ENV](&ENV env, &span sp,
-                                 @expr e, @expr ix, ann a) -> @expr {
+                                 &@expr e, &@expr ix, &ann a) -> @expr {
     ret @respan(sp, ast.expr_index(e, ix, a));
 }
 
 fn identity_fold_expr_path[ENV](&ENV env, &span sp,
                                 &path p, &Option.t[def] d,
-                                ann a) -> @expr {
+                                &ann a) -> @expr {
     ret @respan(sp, ast.expr_path(p, d, a));
 }
 
 fn identity_fold_expr_ext[ENV](&ENV env, &span sp,
-                               &path p, vec[@expr] args,
-                               Option.t[str] body,
-                               @expr expanded,
-                               ann a) -> @expr {
+                               &path p, &vec[@expr] args,
+                               &Option.t[str] body,
+                               &@expr expanded,
+                               &ann a) -> @expr {
     ret @respan(sp, ast.expr_ext(p, args, body, expanded, a));
 }
 
-fn identity_fold_expr_fail[ENV](&ENV env, &span sp, ann a) -> @expr {
+fn identity_fold_expr_fail[ENV](&ENV env, &span sp, &ann a) -> @expr {
     ret @respan(sp, ast.expr_fail(a));
 }
 
-fn identity_fold_expr_break[ENV](&ENV env, &span sp, ann a) -> @expr {
+fn identity_fold_expr_break[ENV](&ENV env, &span sp, &ann a) -> @expr {
     ret @respan(sp, ast.expr_break(a));
 }
 
-fn identity_fold_expr_cont[ENV](&ENV env, &span sp, ann a) -> @expr {
+fn identity_fold_expr_cont[ENV](&ENV env, &span sp, &ann a) -> @expr {
     ret @respan(sp, ast.expr_cont(a));
 }
 
 fn identity_fold_expr_ret[ENV](&ENV env, &span sp,
-                               &Option.t[@expr] rv, ann a) -> @expr {
+                               &Option.t[@expr] rv, &ann a) -> @expr {
     ret @respan(sp, ast.expr_ret(rv, a));
 }
 
 fn identity_fold_expr_put[ENV](&ENV env, &span sp,
-                               &Option.t[@expr] rv, ann a) -> @expr {
+                               &Option.t[@expr] rv, &ann a) -> @expr {
     ret @respan(sp, ast.expr_put(rv, a));
 }
 
-fn identity_fold_expr_be[ENV](&ENV env, &span sp, @expr x, ann a) -> @expr {
+fn identity_fold_expr_be[ENV](&ENV env, &span sp,
+                              &@expr x, &ann a) -> @expr {
     ret @respan(sp, ast.expr_be(x, a));
 }
 
-fn identity_fold_expr_log[ENV](&ENV e, &span sp, int lvl, @expr x,
-                               ann a) -> @expr {
+fn identity_fold_expr_log[ENV](&ENV e, &span sp, int lvl, &@expr x,
+                               &ann a) -> @expr {
     ret @respan(sp, ast.expr_log(lvl, x, a));
 }
 
-fn identity_fold_expr_check[ENV](&ENV e, &span sp, @expr x, ann a)
+fn identity_fold_expr_check[ENV](&ENV e, &span sp, &@expr x, &ann a)
     -> @expr {
     ret @respan(sp, ast.expr_check(x, a));
 }
 
-fn identity_fold_expr_assert[ENV](&ENV e, &span sp, @expr x, ann a)
+fn identity_fold_expr_assert[ENV](&ENV e, &span sp, &@expr x, &ann a)
     -> @expr {
     ret @respan(sp, ast.expr_assert(x, a));
 }
 
-fn identity_fold_expr_port[ENV](&ENV e, &span sp, ann a) -> @expr {
+fn identity_fold_expr_port[ENV](&ENV e, &span sp, &ann a) -> @expr {
     ret @respan(sp, ast.expr_port(a));
 }
 
-fn identity_fold_expr_chan[ENV](&ENV e, &span sp, @expr x, ann a) -> @expr {
+fn identity_fold_expr_chan[ENV](&ENV e, &span sp, &@expr x,
+                                &ann a) -> @expr {
     ret @respan(sp, ast.expr_chan(x, a));
 }
 
 // Decl identities.
 
 fn identity_fold_decl_local[ENV](&ENV e, &span sp,
-                                 @ast.local local) -> @decl {
+                                 &@ast.local local) -> @decl {
     ret @respan(sp, ast.decl_local(local));
 }
 
-fn identity_fold_decl_item[ENV](&ENV e, &span sp, @item i) -> @decl {
+fn identity_fold_decl_item[ENV](&ENV e, &span sp, &@item i) -> @decl {
     ret @respan(sp, ast.decl_item(i));
 }
 
 
 // Pat identities.
 
-fn identity_fold_pat_wild[ENV](&ENV e, &span sp, ann a) -> @pat {
+fn identity_fold_pat_wild[ENV](&ENV e, &span sp, &ann a) -> @pat {
     ret @respan(sp, ast.pat_wild(a));
 }
 
-fn identity_fold_pat_lit[ENV](&ENV e, &span sp, @ast.lit lit, ann a) -> @pat {
+fn identity_fold_pat_lit[ENV](&ENV e, &span sp,
+                              &@ast.lit lit, &ann a) -> @pat {
     ret @respan(sp, ast.pat_lit(lit, a));
 }
 
-fn identity_fold_pat_bind[ENV](&ENV e, &span sp, ident i, def_id did, ann a)
+fn identity_fold_pat_bind[ENV](&ENV e, &span sp, &ident i,
+                               &def_id did, &ann a)
         -> @pat {
     ret @respan(sp, ast.pat_bind(i, did, a));
 }
 
-fn identity_fold_pat_tag[ENV](&ENV e, &span sp, path p, vec[@pat] args,
-                              Option.t[ast.variant_def] d, ann a) -> @pat {
+fn identity_fold_pat_tag[ENV](&ENV e, &span sp, &path p, &vec[@pat] args,
+                              &Option.t[ast.variant_def] d, &ann a) -> @pat {
     ret @respan(sp, ast.pat_tag(p, args, d, a));
 }
 
 
 // Stmt identities.
 
-fn identity_fold_stmt_decl[ENV](&ENV env, &span sp, @decl d, ann a) -> @stmt {
+fn identity_fold_stmt_decl[ENV](&ENV env, &span sp,
+                                &@decl d, &ann a) -> @stmt {
     ret @respan(sp, ast.stmt_decl(d, a));
 }
 
-fn identity_fold_stmt_expr[ENV](&ENV e, &span sp, @expr x, ann a) -> @stmt {
+fn identity_fold_stmt_expr[ENV](&ENV e, &span sp,
+                                &@expr x, &ann a) -> @stmt {
     ret @respan(sp, ast.stmt_expr(x, a));
 }
 
 
 // Item identities.
 
-fn identity_fold_item_const[ENV](&ENV e, &span sp, ident i,
-                                 @ty t, @expr ex,
-                                 def_id id, ann a) -> @item {
+fn identity_fold_item_const[ENV](&ENV e, &span sp, &ident i,
+                                  &@ty t, &@expr ex,
+                                 &def_id id, &ann a) -> @item {
     ret @respan(sp, ast.item_const(i, t, ex, id, a));
 }
 
-fn identity_fold_item_fn[ENV](&ENV e, &span sp, ident i,
-                              &ast._fn f, vec[ast.ty_param] ty_params,
-                              def_id id, ann a) -> @item {
+fn identity_fold_item_fn[ENV](&ENV e, &span sp, &ident i,
+                              &ast._fn f, &vec[ast.ty_param] ty_params,
+                              &def_id id, &ann a) -> @item {
     ret @respan(sp, ast.item_fn(i, f, ty_params, id, a));
 }
 
-fn identity_fold_native_item_fn[ENV](&ENV e, &span sp, ident i,
-                                     Option.t[str] link_name,
+fn identity_fold_native_item_fn[ENV](&ENV e, &span sp, &ident i,
+                                     &Option.t[str] link_name,
                                      &ast.fn_decl decl,
-                                     vec[ast.ty_param] ty_params,
-                                     def_id id, ann a) -> @native_item {
+                                     &vec[ast.ty_param] ty_params,
+                                     &def_id id, &ann a) -> @native_item {
     ret @respan(sp, ast.native_item_fn(i, link_name, decl, ty_params, id, a));
 }
 
-fn identity_fold_item_mod[ENV](&ENV e, &span sp, ident i,
-                               &ast._mod m, def_id id) -> @item {
+fn identity_fold_item_mod[ENV](&ENV e, &span sp, &ident i,
+                               &ast._mod m, &def_id id) -> @item {
     ret @respan(sp, ast.item_mod(i, m, id));
 }
 
-fn identity_fold_item_native_mod[ENV](&ENV e, &span sp, ident i,
-                                      &ast.native_mod m, def_id id) -> @item {
+fn identity_fold_item_native_mod[ENV](&ENV e, &span sp, &ident i,
+                                      &ast.native_mod m, &def_id id) -> @item {
     ret @respan(sp, ast.item_native_mod(i, m, id));
 }
 
-fn identity_fold_item_ty[ENV](&ENV e, &span sp, ident i,
-                              @ty t, vec[ast.ty_param] ty_params,
-                              def_id id, ann a) -> @item {
+fn identity_fold_item_ty[ENV](&ENV e, &span sp, &ident i,
+                              &@ty t, &vec[ast.ty_param] ty_params,
+                              &def_id id, &ann a) -> @item {
     ret @respan(sp, ast.item_ty(i, t, ty_params, id, a));
 }
 
-fn identity_fold_native_item_ty[ENV](&ENV e, &span sp, ident i,
-                                     def_id id) -> @native_item {
+fn identity_fold_native_item_ty[ENV](&ENV e, &span sp, &ident i,
+                                     &def_id id) -> @native_item {
     ret @respan(sp, ast.native_item_ty(i, id));
 }
 
-fn identity_fold_item_tag[ENV](&ENV e, &span sp, ident i,
-                               vec[ast.variant] variants,
-                               vec[ast.ty_param] ty_params,
-                               def_id id, ann a) -> @item {
+fn identity_fold_item_tag[ENV](&ENV e, &span sp, &ident i,
+                               &vec[ast.variant] variants,
+                               &vec[ast.ty_param] ty_params,
+                               &def_id id, &ann a) -> @item {
     ret @respan(sp, ast.item_tag(i, variants, ty_params, id, a));
 }
 
-fn identity_fold_item_obj[ENV](&ENV e, &span sp, ident i,
-                               &ast._obj ob, vec[ast.ty_param] ty_params,
-                               ast.obj_def_ids odid, ann a) -> @item {
+fn identity_fold_item_obj[ENV](&ENV e, &span sp, &ident i,
+                               &ast._obj ob, &vec[ast.ty_param] ty_params,
+                               &ast.obj_def_ids odid, &ann a) -> @item {
     ret @respan(sp, ast.item_obj(i, ob, ty_params, odid, a));
 }
 
 // View Item folds.
 
-fn identity_fold_view_item_use[ENV](&ENV e, &span sp, ident i,
-                                    vec[@meta_item] meta_items,
-                                    def_id id, Option.t[int] cnum)
+fn identity_fold_view_item_use[ENV](&ENV e, &span sp, &ident i,
+                                    &vec[@meta_item] meta_items,
+                                    &def_id id, &Option.t[int] cnum)
     -> @view_item {
     ret @respan(sp, ast.view_item_use(i, meta_items, id, cnum));
 }
 
-fn identity_fold_view_item_import[ENV](&ENV e, &span sp, ident i,
-                                       vec[ident] is, def_id id,
-                                       Option.t[def] target_def)
+fn identity_fold_view_item_import[ENV](&ENV e, &span sp, &ident i,
+                                       &vec[ident] is, &def_id id,
+                                       &Option.t[def] target_def)
     -> @view_item {
     ret @respan(sp, ast.view_item_import(i, is, id, target_def));
 }
 
-fn identity_fold_view_item_export[ENV](&ENV e, &span sp, ident i)
+fn identity_fold_view_item_export[ENV](&ENV e, &span sp, &ident i)
     -> @view_item {
     ret @respan(sp, ast.view_item_export(i));
 }
 
 // Annotation folding.
 
-fn identity_fold_ann[ENV](&ENV e, ann a) -> ann {
+fn identity_fold_ann[ENV](&ENV e, &ann a) -> ann {
     ret a;
 }
 
@@ -1543,9 +1561,9 @@ fn identity_fold_block[ENV](&ENV e, &span sp, &ast.block_ blk) -> block {
 }
 
 fn identity_fold_fn_decl[ENV](&ENV e,
-                              vec[arg] inputs,
-                              @ty output,
-                              purity p) -> ast.fn_decl {
+                              &vec[arg] inputs,
+                              &@ty output,
+                              &purity p) -> ast.fn_decl {
     ret rec(inputs=inputs, output=output, purity=p);
 }
 
@@ -1566,34 +1584,34 @@ fn identity_fold_native_mod[ENV](&ENV e,
 }
 
 fn identity_fold_crate[ENV](&ENV e, &span sp,
-                            vec[@ast.crate_directive] cdirs,
+                            &vec[@ast.crate_directive] cdirs,
                             &ast._mod m) -> @ast.crate {
     ret @respan(sp, rec(directives=cdirs, module=m));
 }
 
 fn identity_fold_obj[ENV](&ENV e,
-                          vec[ast.obj_field] fields,
-                          vec[@ast.method] methods,
-                          Option.t[@ast.method] dtor) -> ast._obj {
+                          &vec[ast.obj_field] fields,
+                          &vec[@ast.method] methods,
+                          &Option.t[@ast.method] dtor) -> ast._obj {
     ret rec(fields=fields, methods=methods, dtor=dtor);
 }
 
 
 // Env update identities.
 
-fn identity_update_env_for_crate[ENV](&ENV e, @ast.crate c) -> ENV {
+fn identity_update_env_for_crate[ENV](&ENV e, &@ast.crate c) -> ENV {
     ret e;
 }
 
-fn identity_update_env_for_item[ENV](&ENV e, @item i) -> ENV {
+fn identity_update_env_for_item[ENV](&ENV e, &@item i) -> ENV {
     ret e;
 }
 
-fn identity_update_env_for_native_item[ENV](&ENV e, @native_item i) -> ENV {
+fn identity_update_env_for_native_item[ENV](&ENV e, &@native_item i) -> ENV {
     ret e;
 }
 
-fn identity_update_env_for_view_item[ENV](&ENV e, @view_item i) -> ENV {
+fn identity_update_env_for_view_item[ENV](&ENV e, &@view_item i) -> ENV {
     ret e;
 }
 
@@ -1601,11 +1619,11 @@ fn identity_update_env_for_block[ENV](&ENV e, &block b) -> ENV {
     ret e;
 }
 
-fn identity_update_env_for_stmt[ENV](&ENV e, @stmt s) -> ENV {
+fn identity_update_env_for_stmt[ENV](&ENV e, &@stmt s) -> ENV {
     ret e;
 }
 
-fn identity_update_env_for_decl[ENV](&ENV e, @decl d) -> ENV {
+fn identity_update_env_for_decl[ENV](&ENV e, &@decl d) -> ENV {
     ret e;
 }
 
@@ -1613,15 +1631,15 @@ fn identity_update_env_for_arm[ENV](&ENV e, &arm a) -> ENV {
     ret e;
 }
 
-fn identity_update_env_for_pat[ENV](&ENV e, @pat p) -> ENV {
+fn identity_update_env_for_pat[ENV](&ENV e, &@pat p) -> ENV {
     ret e;
 }
 
-fn identity_update_env_for_expr[ENV](&ENV e, @expr x) -> ENV {
+fn identity_update_env_for_expr[ENV](&ENV e, &@expr x) -> ENV {
     ret e;
 }
 
-fn identity_update_env_for_ty[ENV](&ENV e, @ty t) -> ENV {
+fn identity_update_env_for_ty[ENV](&ENV e, &@ty t) -> ENV {
     ret e;
 }
 
@@ -1697,7 +1715,7 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
          = bind identity_fold_expr_check[ENV](_,_,_,_),
          fold_expr_assert
          = bind identity_fold_expr_assert[ENV](_,_,_,_),
-              
+
          fold_expr_port   = bind identity_fold_expr_port[ENV](_,_,_),
          fold_expr_chan   = bind identity_fold_expr_chan[ENV](_,_,_,_),
 
diff --git a/src/comp/middle/resolve.rs b/src/comp/middle/resolve.rs
index 433b4734..5fb2eb04 100644
--- a/src/comp/middle/resolve.rs
+++ b/src/comp/middle/resolve.rs
@@ -604,9 +604,9 @@ fn lookup_name_wrapped(&env e, ast.ident i, namespace ns, direction dir)
     }
 }
 
-fn fold_pat_tag(&env e, &span sp, ast.path p, vec[@ast.pat] args,
-                Option.t[ast.variant_def] old_def,
-                ann a) -> @ast.pat {
+fn fold_pat_tag(&env e, &span sp, &ast.path p, &vec[@ast.pat] args,
+                &Option.t[ast.variant_def] old_def,
+                &ann a) -> @ast.pat {
     auto len = Vec.len[ast.ident](p.node.idents);
     auto last_id = p.node.idents.(len - 1u);
     auto new_def;
@@ -647,7 +647,7 @@ fn fold_pat_tag(&env e, &span sp, ast.path p, vec[@ast.pat] args,
 // expressions tacked on the end.
 
 fn fold_expr_path(&env e, &span sp, &ast.path p, &Option.t[def] d,
-                  ann a) -> @ast.expr {
+                  &ann a) -> @ast.expr {
     auto n_idents = Vec.len[ast.ident](p.node.idents);
     assert (n_idents != 0u);
 
@@ -683,9 +683,9 @@ fn fold_expr_path(&env e, &span sp, &ast.path p, &Option.t[def] d,
 }
 
 fn fold_view_item_import(&env e, &span sp,
-                         import_map index, ident i,
-                         vec[ident] is, ast.def_id id,
-                         Option.t[def] target_id) -> @ast.view_item {
+                         &import_map index, &ident i,
+                         &vec[ident] is, &ast.def_id id,
+                         &Option.t[def] target_id) -> @ast.view_item {
     // Produce errors for invalid imports
     auto len = Vec.len[ast.ident](is);
     auto last_id = is.(len - 1u);
@@ -703,7 +703,7 @@ fn fold_view_item_import(&env e, &span sp,
                                                               target_def));
 }
 
-fn fold_ty_path(&env e, &span sp, ast.path p, &Option.t[def] d) -> @ast.ty {
+fn fold_ty_path(&env e, &span sp, &ast.path p, &Option.t[def] d) -> @ast.ty {
     auto index = new_def_hash[def_wrap]();
     auto d = find_final_def(e, index, sp, p.node.idents, ns_type,
                             none[ast.def_id]);
@@ -711,22 +711,22 @@ fn fold_ty_path(&env e, &span sp, ast.path p, &Option.t[def] d) -> @ast.ty {
     ret @fold.respan[ast.ty_](sp, ast.ty_path(p, some(unwrap_def(d))));
 }
 
-fn update_env_for_crate(&env e, @ast.crate c) -> env {
+fn update_env_for_crate(&env e, &@ast.crate c) -> env {
     ret rec(scopes = cons[scope](scope_crate(c), @e.scopes) with e);
 }
 
-fn update_env_for_item(&env e, @ast.item i) -> env {
+fn update_env_for_item(&env e, &@ast.item i) -> env {
     ret rec(scopes = cons[scope](scope_item(i), @e.scopes) with e);
 }
 
-fn update_env_for_native_item(&env e, @ast.native_item i) -> env {
+fn update_env_for_native_item(&env e, &@ast.native_item i) -> env {
     ret rec(scopes = cons[scope](scope_native_item(i), @e.scopes) with e);
 }
 
 // Not actually called by fold, but here since this is analogous to
 // update_env_for_item() above and is called by find_final_def().
-fn update_env_for_external_mod(&env e, ast.def_id mod_id,
-                               vec[ast.ident] idents) -> env {
+fn update_env_for_external_mod(&env e, &ast.def_id mod_id,
+                               &vec[ast.ident] idents) -> env {
     ret rec(scopes = cons[scope](scope_external_mod(mod_id, idents),
                                  @e.scopes)
             with e);
@@ -736,7 +736,7 @@ fn update_env_for_block(&env e, &ast.block b) -> env {
     ret rec(scopes = cons[scope](scope_block(b), @e.scopes) with e);
 }
 
-fn update_env_for_expr(&env e, @ast.expr x) -> env {
+fn update_env_for_expr(&env e, &@ast.expr x) -> env {
     alt (x.node) {
         case (ast.expr_for(?d, _, _, _)) {
             ret rec(scopes = cons[scope](scope_loop(d), @e.scopes) with e);
@@ -753,7 +753,7 @@ fn update_env_for_arm(&env e, &ast.arm p) -> env {
     ret rec(scopes = cons[scope](scope_arm(p), @e.scopes) with e);
 }
 
-fn resolve_imports(session.session sess, @ast.crate crate) -> @ast.crate {
+fn resolve_imports(session.session sess, &@ast.crate crate) -> @ast.crate {
     let fold.ast_fold[env] fld = fold.new_identity_fold[env]();
 
     auto import_index = new_def_hash[def_wrap]();
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index 1d888949..cdccb828 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -631,7 +631,7 @@ mod Collect {
         ret result;
     }
 
-    fn collect(&@ty_item_table id_to_ty_item, @ast.item i) -> @ty_item_table {
+    fn collect(&@ty_item_table id_to_ty_item, &@ast.item i) -> @ty_item_table {
         alt (i.node) {
             case (ast.item_ty(_, _, _, ?def_id, _)) {
                 id_to_ty_item.insert(def_id, any_item_rust(i));
@@ -647,7 +647,7 @@ mod Collect {
         ret id_to_ty_item;
     }
 
-    fn collect_native(&@ty_item_table id_to_ty_item, @ast.native_item i)
+    fn collect_native(&@ty_item_table id_to_ty_item, &@ast.native_item i)
         -> @ty_item_table {
         alt (i.node) {
             case (ast.native_item_ty(_, ?def_id)) {
@@ -662,7 +662,7 @@ mod Collect {
         ret id_to_ty_item;
     }
 
-    fn convert(&@env e, @ast.item i) -> @env {
+    fn convert(&@env e, &@ast.item i) -> @env {
         auto abi = e.abi;
         alt (i.node) {
             case (ast.item_mod(_, _, _)) {
@@ -681,32 +681,32 @@ mod Collect {
         ret @rec(abi=abi with *e);
     }
 
-    fn convert_native(&@env e, @ast.native_item i) -> @env {
+    fn convert_native(&@env e, &@ast.native_item i) -> @env {
         ty_of_native_item(e.cx, i, e.abi);
         ret e;
     }
 
-    fn fold_item_const(&@env e, &span sp, ast.ident i,
-                       @ast.ty t, @ast.expr ex,
-                       ast.def_id id, ast.ann a) -> @ast.item {
+    fn fold_item_const(&@env e, &span sp, &ast.ident i,
+                       &@ast.ty t, &@ast.expr ex,
+                       &ast.def_id id, &ast.ann a) -> @ast.item {
         // assert (e.cx.type_cache.contains_key(id));
         auto typ = e.cx.type_cache.get(id)._1;
         auto item = ast.item_const(i, t, ex, id, triv_ann(typ));
         ret @fold.respan[ast.item_](sp, item);
     }
 
-    fn fold_item_fn(&@env e, &span sp, ast.ident i,
-                    &ast._fn f, vec[ast.ty_param] ty_params,
-                    ast.def_id id, ast.ann a) -> @ast.item {
+    fn fold_item_fn(&@env e, &span sp, &ast.ident i,
+                    &ast._fn f, &vec[ast.ty_param] ty_params,
+                    &ast.def_id id, &ast.ann a) -> @ast.item {
         // assert (e.cx.type_cache.contains_key(id));
         auto typ = e.cx.type_cache.get(id)._1;
         auto item = ast.item_fn(i, f, ty_params, id, triv_ann(typ));
         ret @fold.respan[ast.item_](sp, item);
     }
 
-    fn fold_native_item_fn(&@env e, &span sp, ast.ident i, Option.t[str] ln,
-                           &ast.fn_decl d, vec[ast.ty_param] ty_params,
-                           ast.def_id id, ast.ann a) -> @ast.native_item {
+    fn fold_native_item_fn(&@env e, &span sp, &ast.ident i, &Option.t[str] ln,
+                           &ast.fn_decl d, &vec[ast.ty_param] ty_params,
+                           &ast.def_id id, &ast.ann a) -> @ast.native_item {
         // assert (e.cx.type_cache.contains_key(id));
         auto typ = e.cx.type_cache.get(id)._1;
         auto item = ast.native_item_fn(i, ln, d, ty_params, id,
@@ -714,7 +714,7 @@ mod Collect {
         ret @fold.respan[ast.native_item_](sp, item);
     }
 
-    fn get_ctor_obj_methods(&@env e, ty.t t) -> vec[method] {
+    fn get_ctor_obj_methods(&@env e, &ty.t t) -> vec[method] {
         alt (struct(e.cx.tcx, t)) {
             case (ty.ty_fn(_,_,?tobj)) {
                 alt (struct(e.cx.tcx, tobj)) {
@@ -735,9 +735,9 @@ mod Collect {
     }
 
 
-    fn fold_item_obj(&@env e, &span sp, ast.ident i,
-                    &ast._obj ob, vec[ast.ty_param] ty_params,
-                    ast.obj_def_ids odid, ast.ann a) -> @ast.item {
+    fn fold_item_obj(&@env e, &span sp, &ast.ident i,
+                    &ast._obj ob, &vec[ast.ty_param] ty_params,
+                    &ast.obj_def_ids odid, &ast.ann a) -> @ast.item {
         // assert (e.cx.type_cache.contains_key(odid.ctor));
         auto t = e.cx.type_cache.get(odid.ctor)._1;
         let vec[method] meth_tys = get_ctor_obj_methods(e, t);
@@ -791,19 +791,19 @@ mod Collect {
         ret @fold.respan[ast.item_](sp, item);
     }
 
-    fn fold_item_ty(&@env e, &span sp, ast.ident i,
-                    @ast.ty t, vec[ast.ty_param] ty_params,
-                    ast.def_id id, ast.ann a) -> @ast.item {
+    fn fold_item_ty(&@env e, &span sp, &ast.ident i,
+                    &@ast.ty t, &vec[ast.ty_param] ty_params,
+                    &ast.def_id id, &ast.ann a) -> @ast.item {
         // assert (e.cx.type_cache.contains_key(id));
         auto typ = e.cx.type_cache.get(id)._1;
         auto item = ast.item_ty(i, t, ty_params, id, triv_ann(typ));
         ret @fold.respan[ast.item_](sp, item);
     }
 
-    fn fold_item_tag(&@env e, &span sp, ast.ident i,
-                     vec[ast.variant] variants,
-                     vec[ast.ty_param] ty_params,
-                     ast.def_id id, ast.ann a) -> @ast.item {
+    fn fold_item_tag(&@env e, &span sp, &ast.ident i,
+                     &vec[ast.variant] variants,
+                     &vec[ast.ty_param] ty_params,
+                     &ast.def_id id, &ast.ann a) -> @ast.item {
         auto variants_t = get_tag_variant_types(e.cx, id, variants,
                                                 ty_params);
         auto typ = e.cx.type_cache.get(id)._1;
@@ -813,7 +813,8 @@ mod Collect {
         ret @fold.respan[ast.item_](sp, item);
     }
 
-    fn collect_item_types(session.session sess, ty.ctxt tcx, @ast.crate crate)
+    fn collect_item_types(&session.session sess, &ty.ctxt tcx,
+                          &@ast.crate crate)
             -> tup(@ast.crate, ty.type_cache, @ty_item_table) {
         // First pass: collect all type item IDs.
         auto module = crate.node.module;
@@ -1523,7 +1524,7 @@ mod Pushdown {
 // Local variable resolution: the phase that finds all the types in the AST
 // and replaces opaque "ty_local" types with the resolved local types.
 
-fn writeback_local(&Option.t[@fn_ctxt] env, &span sp, @ast.local local)
+fn writeback_local(&Option.t[@fn_ctxt] env, &span sp, &@ast.local local)
         -> @ast.decl {
     auto fcx = Option.get[@fn_ctxt](env);
 
@@ -1545,7 +1546,7 @@ fn writeback_local(&Option.t[@fn_ctxt] env, &span sp, @ast.local local)
     ret @fold.respan[ast.decl_](sp, ast.decl_local(local_wb));
 }
 
-fn resolve_local_types_in_annotation(&Option.t[@fn_ctxt] env, ast.ann ann)
+fn resolve_local_types_in_annotation(&Option.t[@fn_ctxt] env, &ast.ann ann)
         -> ast.ann {
     fn resolver(@fn_ctxt fcx, ty.t typ) -> ty.t {
         alt (struct(fcx.ccx.tcx, typ)) {
@@ -1574,7 +1575,7 @@ fn resolve_local_types_in_annotation(&Option.t[@fn_ctxt] env, ast.ann ann)
 
 fn resolve_local_types_in_block(&@fn_ctxt fcx, &ast.block block)
         -> ast.block {
-    fn update_env_for_item(&Option.t[@fn_ctxt] env, @ast.item i)
+    fn update_env_for_item(&Option.t[@fn_ctxt] env, &@ast.item i)
             -> Option.t[@fn_ctxt] {
         ret none[@fn_ctxt];
     }
@@ -1588,13 +1589,11 @@ fn resolve_local_types_in_block(&@fn_ctxt fcx, &ast.block block)
     auto rltia = bind resolve_local_types_in_annotation(_,_);
     auto uefi = update_env_for_item;
     auto kg = keep_going;
-    fld = @rec(
-        fold_decl_local = wbl,
-        fold_ann = rltia,
-        update_env_for_item = uefi,
-        keep_going = kg
-        with *fld
-    );
+    fld = @rec(fold_decl_local = wbl,
+               fold_ann = rltia,
+               update_env_for_item = uefi,
+               keep_going = kg
+               with *fld);
     ret fold.fold_block[Option.t[@fn_ctxt]](some[@fn_ctxt](fcx), fld, block);
 }
 
@@ -2872,9 +2871,9 @@ fn check_fn(&@crate_ctxt ccx, &ast.fn_decl decl, ast.proto proto,
     ret fn_t;
 }
 
-fn check_item_fn(&@crate_ctxt ccx, &span sp, ast.ident ident, &ast._fn f,
-                 vec[ast.ty_param] ty_params, ast.def_id id,
-                 ast.ann ann) -> @ast.item {
+fn check_item_fn(&@crate_ctxt ccx, &span sp, &ast.ident ident, &ast._fn f,
+                 &vec[ast.ty_param] ty_params, &ast.def_id id,
+                 &ast.ann ann) -> @ast.item {
 
     // FIXME: duplicate work: the item annotation already has the arg types
     // and return type translated to typeck.ty values. We don't need do to it
@@ -2893,7 +2892,7 @@ fn check_item_fn(&@crate_ctxt ccx, &span sp, ast.ident ident, &ast._fn f,
     ret @fold.respan[ast.item_](sp, item);
 }
 
-fn update_obj_fields(&@crate_ctxt ccx, @ast.item i) -> @crate_ctxt {
+fn update_obj_fields(&@crate_ctxt ccx, &@ast.item i) -> @crate_ctxt {
     alt (i.node) {
         case (ast.item_obj(_, ?ob, _, ?obj_def_ids, _)) {
             let ast.def_id di = obj_def_ids.ty;
diff --git a/src/comp/middle/typestate_check.rs b/src/comp/middle/typestate_check.rs
index e571fa21..7a9f9da7 100644
--- a/src/comp/middle/typestate_check.rs
+++ b/src/comp/middle/typestate_check.rs
@@ -309,7 +309,7 @@ fn num_locals(fn_info m) -> uint {
   ret m.size();
 }
 
-fn collect_local(&@vec[tup(ident, def_id)] vars, &span sp, @ast.local loc) 
+fn collect_local(&@vec[tup(ident, def_id)] vars, &span sp, &@ast.local loc)
     -> @decl {
     log("collect_local: pushing " + loc.ident);
     Vec.push[tup(ident, def_id)](*vars, tup(loc.ident, loc.id));
@@ -351,19 +351,20 @@ fn mk_fn_info(_fn f) -> fn_info {
   ret res;
 }
 
-/* extends mk_fn_info to a function item, side-effecting the map fi from 
+/* extends mk_fn_info to a function item, side-effecting the map fi from
    function IDs to fn_info maps */
-fn mk_fn_info_item_fn(&fn_info_map fi, &span sp, ident i, &ast._fn f,
-                 vec[ast.ty_param] ty_params, def_id id, ann a) -> @item {
+fn mk_fn_info_item_fn(&fn_info_map fi, &span sp, &ident i, &ast._fn f,
+                 &vec[ast.ty_param] ty_params, &def_id id, &ann a) -> @item {
   fi.insert(id, mk_fn_info(f));
   log(i + " has " + uistr(num_locals(mk_fn_info(f))) + " local vars");
   ret @respan(sp, item_fn(i, f, ty_params, id, a));
 }
 
-/* extends mk_fn_info to an obj item, side-effecting the map fi from 
+/* extends mk_fn_info to an obj item, side-effecting the map fi from
    function IDs to fn_info maps */
-fn mk_fn_info_item_obj(&fn_info_map fi, &span sp, ident i, &ast._obj o,
-     vec[ast.ty_param] ty_params, ast.obj_def_ids odid, ann a) -> @item {
+fn mk_fn_info_item_obj(&fn_info_map fi, &span sp, &ident i, &ast._obj o,
+                       &vec[ast.ty_param] ty_params,
+                       &ast.obj_def_ids odid, &ann a) -> @item {
     auto all_methods = Vec.clone[@method](o.methods);
     plus_option[@method](all_methods, o.dtor);
     for (@method m in all_methods) {
@@ -1251,14 +1252,15 @@ fn find_pre_post_fn(&fn_info_map fm, &fn_info fi, &_fn f) -> () {
     find_pre_post_block(fm, fi, f.body);
 }
 
-fn check_item_fn(&fn_info_map fm, &span sp, ident i, &ast._fn f,
-                 vec[ast.ty_param] ty_params, def_id id, ann a) -> @item {
+fn check_item_fn(&fn_info_map fm, &span sp, &ident i, &ast._fn f,
+                 &vec[ast.ty_param] ty_params,
+                 &def_id id, &ann a) -> @item {
 
     log("check_item_fn:");
     log_fn(f, i, ty_params);
 
   assert (fm.contains_key(id));
-  find_pre_post_fn(fm, fm.get(id), f);  
+  find_pre_post_fn(fm, fm.get(id), f);
 
   ret @respan(sp, ast.item_fn(i, f, ty_params, id, a));
 }
@@ -2006,9 +2008,9 @@ fn check_fn_states(&fn_info_map f_info_map, &fn_info f_info, &ast._fn f)
     check_states_against_conditions(f_info, f);
 }
 
-fn check_item_fn_state(&fn_info_map f_info_map, &span sp, ident i,
-                       &ast._fn f, vec[ast.ty_param] ty_params, def_id id,
-                       ann a) -> @item {
+fn check_item_fn_state(&fn_info_map f_info_map, &span sp, &ident i,
+                       &ast._fn f, &vec[ast.ty_param] ty_params,
+                       &def_id id, &ann a) -> @item {
 
   /* Look up the var-to-bit-num map for this function */
   assert (f_info_map.contains_key(id));
@@ -2026,8 +2028,9 @@ fn check_method_states(&fn_info_map f_info_map, @method m) -> () {
     check_fn_states(f_info_map, f_info, m.node.meth);
 }
 
-fn check_obj_state(&fn_info_map f_info_map, vec[obj_field] fields,
-                  vec[@method] methods, Option.t[@method] dtor) -> ast._obj {
+fn check_obj_state(&fn_info_map f_info_map, &vec[obj_field] fields,
+                   &vec[@method] methods,
+                   &Option.t[@method] dtor) -> ast._obj {
     fn one(fn_info_map fm, &@method m) -> () {
         ret check_method_states(fm, m);
     }
@@ -2037,7 +2040,7 @@ fn check_obj_state(&fn_info_map f_info_map, vec[obj_field] fields,
     ret rec(fields=fields, methods=methods, dtor=dtor);
 }
 
-fn init_ann(&fn_info fi, ann a) -> ann {
+fn init_ann(&fn_info fi, &ann a) -> ann {
     alt (a) {
         case (ann_none) {
             //            log("init_ann: shouldn't see ann_none");
@@ -2053,7 +2056,7 @@ fn init_ann(&fn_info fi, ann a) -> ann {
     }
 }
 
-fn init_blank_ann(&() ignore, ann a) -> ann {
+fn init_blank_ann(&() ignore, &ann a) -> ann {
     alt (a) {
         case (ann_none) {
             //            log("init_blank_ann: shouldn't see ann_none");
@@ -2492,7 +2495,7 @@ fn annotate_crate(&fn_info_map fm, &@ast.crate crate) -> @ast.crate {
 fn check_crate(@ast.crate crate) -> @ast.crate {
   /* Build the global map from function id to var-to-bit-num-map */
   auto fm = mk_f_to_fn_info(crate);
-  
+
   /* Add a blank ts_ann to every statement (and expression) */
   auto with_anns = annotate_crate(fm, crate);