Alias-ify walk, typeck, metadata. Cuts another 80kb off rustc.

6 files changed, 153 insertions, 150 deletions

diff --git a/src/comp/middle/capture.rs b/src/comp/middle/capture.rs
index 003c38972f8..d61edacad5a 100644
--- a/src/comp/middle/capture.rs
+++ b/src/comp/middle/capture.rs
@@ -17,7 +17,7 @@ fn current_context(&env e) -> ast.def_id {
     ret e.current_context.(Vec.len(e.current_context) - 1u);
 }
 
-fn enter_item(@env e, @ast.item i) {
+fn enter_item(@env e, &@ast.item i) {
     alt (i.node) {
         case (ast.item_fn(?name, _, _, ?id, _)) {
             Vec.push(e.current_context, id);
@@ -29,7 +29,7 @@ fn enter_item(@env e, @ast.item i) {
     }
 }
 
-fn leave_item(@env e, @ast.item i) {
+fn leave_item(@env e, &@ast.item i) {
     alt (i.node) {
         case (ast.item_fn(?name, _, _, ?id, _)) {
             Vec.pop(e.current_context);
@@ -41,7 +41,7 @@ fn leave_item(@env e, @ast.item i) {
     }
 }
 
-fn walk_expr(@env e, @ast.expr x) {
+fn walk_expr(@env e, &@ast.expr x) {
     alt (x.node) {
         case (ast.expr_for(?d, _, _, _)) {
             alt (d.node) {
diff --git a/src/comp/middle/metadata.rs b/src/comp/middle/metadata.rs
index c4563cf2b19..dee9046d77f 100644
--- a/src/comp/middle/metadata.rs
+++ b/src/comp/middle/metadata.rs
@@ -61,26 +61,26 @@ tag abbrev_ctxt {
 mod Encode {
 
     type ctxt = rec(
-        fn(ast.def_id) -> str ds,           // Def -> str Callback.
+        fn(&ast.def_id) -> str ds,          // Def -> str Callback.
         ty.ctxt tcx,                        // The type context.
         abbrev_ctxt abbrevs
     );
 
-    fn cx_uses_abbrevs(@ctxt cx) -> bool {
+    fn cx_uses_abbrevs(&@ctxt cx) -> bool {
         alt (cx.abbrevs) {
             case (ac_no_abbrevs)     { ret false; }
             case (ac_use_abbrevs(_)) { ret true; }
         }
     }
 
-    fn ty_str(@ctxt cx, ty.t t) -> str {
+    fn ty_str(&@ctxt cx, &ty.t t) -> str {
         assert (!cx_uses_abbrevs(cx));
         auto sw = IO.string_writer();
         enc_ty(sw.get_writer(), cx, t);
         ret sw.get_str();
     }
 
-    fn enc_ty(IO.writer w, @ctxt cx, ty.t t) {
+    fn enc_ty(&IO.writer w, &@ctxt cx, &ty.t t) {
         alt (cx.abbrevs) {
             case (ac_no_abbrevs) { enc_sty(w, cx, ty.struct(cx.tcx, t)); }
             case (ac_use_abbrevs(?abbrevs)) {
@@ -121,7 +121,7 @@ mod Encode {
         }
     }
 
-    fn enc_mt(IO.writer w, @ctxt cx, &ty.mt mt) {
+    fn enc_mt(&IO.writer w, &@ctxt cx, &ty.mt mt) {
         alt (mt.mut) {
             case (ast.imm)       { }
             case (ast.mut)       { w.write_char('m'); }
@@ -130,7 +130,7 @@ mod Encode {
         enc_ty(w, cx, mt.ty);
     }
 
-    fn enc_sty(IO.writer w, @ctxt cx, ty.sty st) {
+    fn enc_sty(&IO.writer w, &@ctxt cx, &ty.sty st) {
         alt (st) {
             case (ty.ty_nil) { w.write_char('n'); }
             case (ty.ty_bool) { w.write_char('b'); }
@@ -231,14 +231,14 @@ mod Encode {
         }
     }
 
-    fn enc_proto(IO.writer w, ast.proto proto) {
+    fn enc_proto(&IO.writer w, ast.proto proto) {
         alt (proto) {
             case (ast.proto_iter) { w.write_char('W'); }
             case (ast.proto_fn) { w.write_char('F'); }
         }
     }
 
-    fn enc_ty_fn(IO.writer w, @ctxt cx, vec[ty.arg] args, ty.t out) {
+    fn enc_ty_fn(&IO.writer w, &@ctxt cx, &vec[ty.arg] args, &ty.t out) {
         w.write_char('[');
         for (ty.arg arg in args) {
             if (arg.mode == ty.mo_alias) { w.write_char('&'); }
@@ -252,14 +252,14 @@ mod Encode {
 
 
 // Returns a Plain Old LLVM String.
-fn C_postr(str s) -> ValueRef {
+fn C_postr(&str s) -> ValueRef {
     ret llvm.LLVMConstString(Str.buf(s), Str.byte_len(s), False);
 }
 
 
 // Path table encoding
 
-fn encode_name(&EBML.writer ebml_w, str name) {
+fn encode_name(&EBML.writer ebml_w, &str name) {
     EBML.start_tag(ebml_w, tag_paths_data_name);
     ebml_w.writer.write(Str.bytes(name));
     EBML.end_tag(ebml_w);
@@ -272,8 +272,8 @@ fn encode_def_id(&EBML.writer ebml_w, &ast.def_id id) {
 }
 
 fn encode_tag_variant_paths(&EBML.writer ebml_w,
-                            vec[ast.variant] variants,
-                            vec[str] path,
+                            &vec[ast.variant] variants,
+                            &vec[str] path,
                             &mutable vec[tup(str, uint)] index) {
     for (ast.variant variant in variants) {
         add_to_index(ebml_w, path, index, variant.node.name);
@@ -285,16 +285,16 @@ fn encode_tag_variant_paths(&EBML.writer ebml_w,
 }
 
 fn add_to_index(&EBML.writer ebml_w,
-                vec[str] path,
+                &vec[str] path,
                 &mutable vec[tup(str, uint)] index,
-                str name) {
+                &str name) {
     auto full_path = path + vec(name);
     index += vec(tup(Str.connect(full_path, "."), ebml_w.writer.tell()));
 }
 
 fn encode_native_module_item_paths(&EBML.writer ebml_w,
                                    &ast.native_mod nmod,
-                                   vec[str] path,
+                                   &vec[str] path,
                                    &mutable vec[tup(str, uint)] index) {
     for (@ast.native_item nitem in nmod.items) {
         alt (nitem.node) {
@@ -318,7 +318,7 @@ fn encode_native_module_item_paths(&EBML.writer ebml_w,
 
 fn encode_module_item_paths(&EBML.writer ebml_w,
                             &ast._mod module,
-                            vec[str] path,
+                            &vec[str] path,
                             &mutable vec[tup(str, uint)] index) {
     // TODO: only encode exported items
     for (@ast.item it in module.items) {
@@ -382,7 +382,7 @@ fn encode_module_item_paths(&EBML.writer ebml_w,
     }
 }
 
-fn encode_item_paths(&EBML.writer ebml_w, @ast.crate crate)
+fn encode_item_paths(&EBML.writer ebml_w, &@ast.crate crate)
         -> vec[tup(str, uint)] {
     let vec[tup(str, uint)] index = vec();
     let vec[str] path = vec();
@@ -401,23 +401,23 @@ fn encode_kind(&EBML.writer ebml_w, u8 c) {
     EBML.end_tag(ebml_w);
 }
 
-fn def_to_str(ast.def_id did) -> str {
+fn def_to_str(&ast.def_id did) -> str {
     ret #fmt("%d:%d", did._0, did._1);
 }
 
-fn encode_type_param_count(&EBML.writer ebml_w, vec[ast.ty_param] tps) {
+fn encode_type_param_count(&EBML.writer ebml_w, &vec[ast.ty_param] tps) {
     EBML.start_tag(ebml_w, tag_items_data_item_ty_param_count);
     EBML.write_vint(ebml_w.writer, Vec.len[ast.ty_param](tps));
     EBML.end_tag(ebml_w);
 }
 
-fn encode_variant_id(&EBML.writer ebml_w, ast.def_id vid) {
+fn encode_variant_id(&EBML.writer ebml_w, &ast.def_id vid) {
     EBML.start_tag(ebml_w, tag_items_data_item_variant);
     ebml_w.writer.write(Str.bytes(def_to_str(vid)));
     EBML.end_tag(ebml_w);
 }
 
-fn encode_type(@trans.crate_ctxt cx, &EBML.writer ebml_w, ty.t typ) {
+fn encode_type(&@trans.crate_ctxt cx, &EBML.writer ebml_w, &ty.t typ) {
     EBML.start_tag(ebml_w, tag_items_data_item_type);
 
     auto f = def_to_str;
@@ -427,14 +427,15 @@ fn encode_type(@trans.crate_ctxt cx, &EBML.writer ebml_w, ty.t typ) {
     EBML.end_tag(ebml_w);
 }
 
-fn encode_symbol(@trans.crate_ctxt cx, &EBML.writer ebml_w, ast.def_id did) {
+fn encode_symbol(&@trans.crate_ctxt cx, &EBML.writer ebml_w,
+                 &ast.def_id did) {
     EBML.start_tag(ebml_w, tag_items_data_item_symbol);
     ebml_w.writer.write(Str.bytes(cx.item_symbols.get(did)));
     EBML.end_tag(ebml_w);
 }
 
-fn encode_discriminant(@trans.crate_ctxt cx, &EBML.writer ebml_w,
-                       ast.def_id did) {
+fn encode_discriminant(&@trans.crate_ctxt cx, &EBML.writer ebml_w,
+                       &ast.def_id did) {
     EBML.start_tag(ebml_w, tag_items_data_item_symbol);
     ebml_w.writer.write(Str.bytes(cx.discrim_symbols.get(did)));
     EBML.end_tag(ebml_w);
@@ -453,10 +454,10 @@ fn encode_obj_type_id(&EBML.writer ebml_w, &ast.def_id id) {
 }
 
 
-fn encode_tag_variant_info(@trans.crate_ctxt cx, &EBML.writer ebml_w,
-                           ast.def_id did, vec[ast.variant] variants,
+fn encode_tag_variant_info(&@trans.crate_ctxt cx, &EBML.writer ebml_w,
+                           &ast.def_id did, &vec[ast.variant] variants,
                            &mutable vec[tup(int, uint)] index,
-                           vec[ast.ty_param] ty_params) {
+                           &vec[ast.ty_param] ty_params) {
     for (ast.variant variant in variants) {
         index += vec(tup(variant.node.id._1, ebml_w.writer.tell()));
 
@@ -547,8 +548,8 @@ fn encode_info_for_item(@trans.crate_ctxt cx, &EBML.writer ebml_w,
     }
 }
 
-fn encode_info_for_native_item(@trans.crate_ctxt cx, &EBML.writer ebml_w,
-                               @ast.native_item nitem) {
+fn encode_info_for_native_item(&@trans.crate_ctxt cx, &EBML.writer ebml_w,
+                               &@ast.native_item nitem) {
     EBML.start_tag(ebml_w, tag_items_data_item);
     alt (nitem.node) {
         case (ast.native_item_ty(_, ?did)) {
@@ -567,7 +568,7 @@ fn encode_info_for_native_item(@trans.crate_ctxt cx, &EBML.writer ebml_w,
     EBML.end_tag(ebml_w);
 }
 
-fn encode_info_for_items(@trans.crate_ctxt cx, &EBML.writer ebml_w)
+fn encode_info_for_items(&@trans.crate_ctxt cx, &EBML.writer ebml_w)
         -> vec[tup(int, uint)] {
     let vec[tup(int, uint)] index = vec();
 
@@ -603,7 +604,7 @@ fn hash_path(&str s) -> uint {
     ret h;
 }
 
-fn create_index[T](vec[tup(T, uint)] index, fn(&T) -> uint hash_fn)
+fn create_index[T](&vec[tup(T, uint)] index, fn(&T) -> uint hash_fn)
         -> vec[vec[tup(T, uint)]] {
     let vec[vec[tup(T, uint)]] buckets = vec();
     for each (uint i in UInt.range(0u, 256u)) {
@@ -619,8 +620,8 @@ fn create_index[T](vec[tup(T, uint)] index, fn(&T) -> uint hash_fn)
     ret buckets;
 }
 
-fn encode_index[T](&EBML.writer ebml_w, vec[vec[tup(T, uint)]] buckets,
-                          fn(IO.writer, &T) write_fn) {
+fn encode_index[T](&EBML.writer ebml_w, &vec[vec[tup(T, uint)]] buckets,
+                   fn(&IO.writer, &T) write_fn) {
     auto writer = IO.new_writer_(ebml_w.writer);
 
     EBML.start_tag(ebml_w, tag_index);
@@ -650,16 +651,16 @@ fn encode_index[T](&EBML.writer ebml_w, vec[vec[tup(T, uint)]] buckets,
     EBML.end_tag(ebml_w);
 }
 
-fn write_str(IO.writer writer, &str s) {
+fn write_str(&IO.writer writer, &str s) {
     writer.write_str(s);
 }
 
-fn write_int(IO.writer writer, &int n) {
+fn write_int(&IO.writer writer, &int n) {
     writer.write_be_uint(n as uint, 4u);
 }
 
 
-fn encode_metadata(@trans.crate_ctxt cx, @ast.crate crate)
+fn encode_metadata(&@trans.crate_ctxt cx, &@ast.crate crate)
         -> ValueRef {
     auto string_w = IO.string_writer();
     auto buf_w = string_w.get_writer().get_buf_writer();
@@ -690,7 +691,7 @@ fn encode_metadata(@trans.crate_ctxt cx, @ast.crate crate)
     ret C_postr(string_w.get_str());
 }
 
-fn write_metadata(@trans.crate_ctxt cx, @ast.crate crate) {
+fn write_metadata(&@trans.crate_ctxt cx, &@ast.crate crate) {
     auto llmeta = C_postr("");
     if (cx.sess.get_opts().shared) {
         llmeta = encode_metadata(cx, crate);
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index cb537b38a1a..7840a129102 100644
--- a/src/comp/middle/trans.rs
+++ b/src/comp/middle/trans.rs
@@ -3569,7 +3569,7 @@ fn collect_upvars(@block_ctxt cx, &ast.block bloc, &ast.def_id initial_decl)
         hashmap[ast.def_id,()] decls
     );
 
-    fn walk_expr(env e, @ast.expr expr) {
+    fn walk_expr(env e, &@ast.expr expr) {
         alt (expr.node) {
             case (ast.expr_path(?path, ?d, _)) {
                 alt (Option.get[ast.def](d)) {
@@ -3589,7 +3589,7 @@ fn collect_upvars(@block_ctxt cx, &ast.block bloc, &ast.def_id initial_decl)
         }
     }
 
-    fn walk_decl(env e, @ast.decl decl) {
+    fn walk_decl(env e, &@ast.decl decl) {
         alt (decl.node) {
             case (ast.decl_local(?local)) {
                 e.decls.insert(local.id, ());
@@ -6949,7 +6949,7 @@ fn new_walk_ctxt() -> @walk_ctxt {
     ret @rec(mutable path=path);
 }
 
-fn enter_item(@walk_ctxt cx, @ast.item item) {
+fn enter_item(@walk_ctxt cx, &@ast.item item) {
     alt (item.node) {
         case (ast.item_fn(?name, _, _, _, _)) {
             Vec.push[str](cx.path, name);
@@ -6964,7 +6964,7 @@ fn enter_item(@walk_ctxt cx, @ast.item item) {
     }
 }
 
-fn leave_item(@walk_ctxt cx, @ast.item item) {
+fn leave_item(@walk_ctxt cx, &@ast.item item) {
     alt (item.node) {
         case (ast.item_fn(_, _, _, _, _)) {
             Vec.pop[str](cx.path);
@@ -6979,7 +6979,7 @@ fn leave_item(@walk_ctxt cx, @ast.item item) {
     }
 }
 
-fn collect_native_item(@crate_ctxt ccx, @walk_ctxt wcx, @ast.native_item i) {
+fn collect_native_item(@crate_ctxt ccx, @walk_ctxt wcx, &@ast.native_item i) {
     alt (i.node) {
         case (ast.native_item_fn(?name, _, _, _, ?fid, ?ann)) {
             ccx.native_items.insert(fid, i);
@@ -6993,7 +6993,7 @@ fn collect_native_item(@crate_ctxt ccx, @walk_ctxt wcx, @ast.native_item i) {
     }
 }
 
-fn collect_item_1(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item i) {
+fn collect_item_1(@crate_ctxt ccx, @walk_ctxt wcx, &@ast.item i) {
     enter_item(wcx, i);
 
     alt (i.node) {
@@ -7019,7 +7019,7 @@ fn collect_item_1(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item i) {
     }
 }
 
-fn collect_item_2(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item i) {
+fn collect_item_2(@crate_ctxt ccx, @walk_ctxt wcx, &@ast.item i) {
     enter_item(wcx, i);
 
     alt (i.node) {
@@ -7055,7 +7055,7 @@ fn collect_items(@crate_ctxt ccx, @ast.crate crate) {
     walk.walk_crate(visitor2, *crate);
 }
 
-fn collect_tag_ctor(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item i) {
+fn collect_tag_ctor(@crate_ctxt ccx, @walk_ctxt wcx, &@ast.item i) {
     enter_item(wcx, i);
 
     alt (i.node) {
@@ -7083,7 +7083,7 @@ fn collect_tag_ctors(@crate_ctxt ccx, @ast.crate crate) {
 
 // The constant translation pass.
 
-fn trans_constant(@crate_ctxt ccx, @walk_ctxt wcx, @ast.item it) {
+fn trans_constant(@crate_ctxt ccx, @walk_ctxt wcx, &@ast.item it) {
     enter_item(wcx, it);
 
     alt (it.node) {
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index 4a630af1b5b..dfdf07d9c2f 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -1046,7 +1046,7 @@ fn type_param(&ctxt cx, &t ty) -> Option.t[uint] {
     ret none[uint];
 }
 
-fn def_to_str(ast.def_id did) -> str {
+fn def_to_str(&ast.def_id did) -> str {
     ret #fmt("%d:%d", did._0, did._1);
 }
 
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index cdee187d0f5..1d888949463 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -77,14 +77,14 @@ type fn_ctxt = rec(ty.t ret_ty,
                    @crate_ctxt ccx);
 
 // Used for ast_ty_to_ty() below.
-type ty_getter = fn(ast.def_id) -> ty.ty_param_count_and_ty;
+type ty_getter = fn(&ast.def_id) -> ty.ty_param_count_and_ty;
 
 // Substitutes the user's explicit types for the parameters in a path
 // expression.
 fn substitute_ty_params(&@crate_ctxt ccx,
-                        ty.t typ,
+                        &ty.t typ,
                         uint ty_param_count,
-                        vec[ty.t] supplied,
+                        &vec[ty.t] supplied,
                         &span sp) -> ty.t {
     fn substituter(@crate_ctxt ccx, vec[ty.t] supplied, ty.t typ) -> ty.t {
         alt (struct(ccx.tcx, typ)) {
@@ -112,7 +112,7 @@ fn substitute_ty_params(&@crate_ctxt ccx,
 
 
 // Returns the type parameter count and the type for the given definition.
-fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn)
+fn ty_param_count_and_ty_for_def(&@fn_ctxt fcx, &ast.span sp, &ast.def defn)
         -> ty_param_count_and_ty {
     alt (defn) {
         case (ast.def_arg(?id)) {
@@ -177,8 +177,8 @@ fn ty_param_count_and_ty_for_def(@fn_ctxt fcx, &ast.span sp, &ast.def defn)
 
 // Instantiates the given path, which must refer to an item with the given
 // number of type parameters and type.
-fn instantiate_path(@fn_ctxt fcx, &ast.path pth, &ty_param_count_and_ty tpt,
-        &span sp) -> ast.ann {
+fn instantiate_path(&@fn_ctxt fcx, &ast.path pth, &ty_param_count_and_ty tpt,
+                    &span sp) -> ast.ann {
     auto ty_param_count = tpt._0;
     auto t = bind_params_in_type(fcx.ccx.tcx, tpt._1);
 
@@ -224,25 +224,25 @@ fn ast_mode_to_mode(ast.mode mode) -> ty.mode {
 // Parses the programmer's textual representation of a type into our internal
 // notion of a type. `getter` is a function that returns the type
 // corresponding to a definition ID.
-fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t {
-    fn ast_arg_to_arg(ty.ctxt tcx,
-                      ty_getter getter,
+fn ast_ty_to_ty(&ty.ctxt tcx, &ty_getter getter, &@ast.ty ast_ty) -> ty.t {
+    fn ast_arg_to_arg(&ty.ctxt tcx,
+                      &ty_getter getter,
                       &rec(ast.mode mode, @ast.ty ty) arg)
             -> rec(ty.mode mode, ty.t ty) {
         auto ty_mode = ast_mode_to_mode(arg.mode);
         ret rec(mode=ty_mode, ty=ast_ty_to_ty(tcx, getter, arg.ty));
     }
 
-    fn ast_mt_to_mt(ty.ctxt tcx,
-                    ty_getter getter,
+    fn ast_mt_to_mt(&ty.ctxt tcx,
+                    &ty_getter getter,
                     &ast.mt mt) -> ty.mt {
         ret rec(ty=ast_ty_to_ty(tcx, getter, mt.ty), mut=mt.mut);
     }
 
-    fn instantiate(ty.ctxt tcx,
-                   ty_getter getter,
-                   ast.def_id id,
-                   vec[@ast.ty] args) -> ty.t {
+    fn instantiate(&ty.ctxt tcx,
+                   &ty_getter getter,
+                   &ast.def_id id,
+                   &vec[@ast.ty] args) -> ty.t {
         // TODO: maybe record cname chains so we can do
         // "foo = int" like OCaml?
         auto params_opt_and_ty = getter(id);
@@ -324,7 +324,7 @@ fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t {
                     typ = instantiate(tcx, getter, id, path.node.types);
                 }
                 case (ast.def_ty_arg(?id)) { typ = ty.mk_param(tcx, id); }
-                case (_)                   { 
+                case (_)                   {
                     tcx.sess.span_err(ast_ty.span,
                        "found type name used as a variable");
                     fail; }
@@ -362,7 +362,7 @@ fn ast_ty_to_ty(ty.ctxt tcx, ty_getter getter, &@ast.ty ast_ty) -> ty.t {
 // A convenience function to use a crate_ctxt to resolve names for
 // ast_ty_to_ty.
 fn ast_ty_to_ty_crate(@crate_ctxt ccx, &@ast.ty ast_ty) -> ty.t {
-    fn getter(@crate_ctxt ccx, ast.def_id id) -> ty.ty_param_count_and_ty {
+    fn getter(@crate_ctxt ccx, &ast.def_id id) -> ty.ty_param_count_and_ty {
         ret ty.lookup_item_type(ccx.sess, ccx.tcx, ccx.type_cache, id);
     }
     auto f = bind getter(ccx, _);
@@ -388,13 +388,13 @@ mod Collect {
                     ty.ctxt tcx);
     type env = rec(@ctxt cx, ast.native_abi abi);
 
-    fn ty_of_fn_decl(@ctxt cx,
-                     fn(&@ast.ty ast_ty) -> ty.t convert,
-                     fn(&ast.arg a) -> arg ty_of_arg,
+    fn ty_of_fn_decl(&@ctxt cx,
+                     &fn(&@ast.ty ast_ty) -> ty.t convert,
+                     &fn(&ast.arg a) -> arg ty_of_arg,
                      &ast.fn_decl decl,
                      ast.proto proto,
-                     vec[ast.ty_param] ty_params,
-                     ast.def_id def_id) -> ty.ty_param_count_and_ty {
+                     &vec[ast.ty_param] ty_params,
+                     &ast.def_id def_id) -> ty.ty_param_count_and_ty {
         auto input_tys = Vec.map[ast.arg,arg](ty_of_arg, decl.inputs);
         auto output_ty = convert(decl.output);
         auto t_fn = ty.mk_fn(cx.tcx, proto, input_tys, output_ty);
@@ -404,13 +404,13 @@ mod Collect {
         ret tpt;
     }
 
-    fn ty_of_native_fn_decl(@ctxt cx,
-                            fn(&@ast.ty ast_ty) -> ty.t convert,
-                            fn(&ast.arg a) -> arg ty_of_arg,
+    fn ty_of_native_fn_decl(&@ctxt cx,
+                            &fn(&@ast.ty ast_ty) -> ty.t convert,
+                            &fn(&ast.arg a) -> arg ty_of_arg,
                             &ast.fn_decl decl,
                             ast.native_abi abi,
-                            vec[ast.ty_param] ty_params,
-                            ast.def_id def_id) -> ty.ty_param_count_and_ty {
+                            &vec[ast.ty_param] ty_params,
+                            &ast.def_id def_id) -> ty.ty_param_count_and_ty {
         auto input_tys = Vec.map[ast.arg,arg](ty_of_arg, decl.inputs);
         auto output_ty = convert(decl.output);
         auto t_fn = ty.mk_native_fn(cx.tcx, abi, input_tys, output_ty);
@@ -420,7 +420,7 @@ mod Collect {
         ret tpt;
     }
 
-    fn getter(@ctxt cx, ast.def_id id) -> ty.ty_param_count_and_ty {
+    fn getter(@ctxt cx, &ast.def_id id) -> ty.ty_param_count_and_ty {
 
         if (id._0 != cx.sess.get_targ_crate_num()) {
             // This is a type we need to load in from the crate reader.
@@ -458,9 +458,9 @@ mod Collect {
     }
 
     fn ty_of_obj(@ctxt cx,
-                 ast.ident id,
+                 &ast.ident id,
                  &ast._obj obj_info,
-                 vec[ast.ty_param] ty_params) -> ty.ty_param_count_and_ty {
+                 &vec[ast.ty_param] ty_params) -> ty.ty_param_count_and_ty {
         auto f = bind ty_of_method(cx, _);
         auto methods = Vec.map[@ast.method,method](f, obj_info.methods);
 
@@ -473,8 +473,8 @@ mod Collect {
     fn ty_of_obj_ctor(@ctxt cx,
                       &ast.ident id,
                       &ast._obj obj_info,
-                      ast.def_id obj_ty_id,
-                      vec[ast.ty_param] ty_params)
+                      &ast.def_id obj_ty_id,
+                      &vec[ast.ty_param] ty_params)
             -> ty.ty_param_count_and_ty {
         auto t_obj = ty_of_obj(cx, id, obj_info, ty_params);
         let vec[arg] t_inputs = vec();
@@ -490,7 +490,7 @@ mod Collect {
         ret tup(t_obj._0, t_fn);
     }
 
-    fn ty_of_item(@ctxt cx, @ast.item it) -> ty.ty_param_count_and_ty {
+    fn ty_of_item(&@ctxt cx, &@ast.item it) -> ty.ty_param_count_and_ty {
 
         auto get = bind getter(cx, _);
         auto convert = bind ast_ty_to_ty(cx.tcx, get, _);
@@ -557,7 +557,7 @@ mod Collect {
         }
     }
 
-    fn ty_of_native_item(@ctxt cx, @ast.native_item it, ast.native_abi abi)
+    fn ty_of_native_item(&@ctxt cx, &@ast.native_item it, ast.native_abi abi)
             -> ty.ty_param_count_and_ty {
         alt (it.node) {
             case (ast.native_item_fn(?ident, ?lname, ?fn_decl,
@@ -584,7 +584,7 @@ mod Collect {
         }
     }
 
-    fn get_tag_variant_types(@ctxt cx, &ast.def_id tag_id,
+    fn get_tag_variant_types(&@ctxt cx, &ast.def_id tag_id,
                              &vec[ast.variant] variants,
                              &vec[ast.ty_param] ty_params)
             -> vec[ast.variant] {
@@ -856,7 +856,8 @@ mod Collect {
 // Type unification
 
 mod Unify {
-    fn simple(@fn_ctxt fcx, ty.t expected, ty.t actual) -> ty.Unify.result {
+    fn simple(&@fn_ctxt fcx, &ty.t expected,
+              &ty.t actual) -> ty.Unify.result {
         // FIXME: horrid botch
         let vec[mutable ty.t] param_substs =
             vec(mutable ty.mk_nil(fcx.ccx.tcx));
@@ -864,8 +865,8 @@ mod Unify {
         ret with_params(fcx, expected, actual, param_substs);
     }
 
-    fn with_params(@fn_ctxt fcx, ty.t expected, ty.t actual,
-                   vec[mutable ty.t] param_substs) -> ty.Unify.result {
+    fn with_params(&@fn_ctxt fcx, &ty.t expected, &ty.t actual,
+                   &vec[mutable ty.t] param_substs) -> ty.Unify.result {
         auto cache_key = tup(expected, actual, param_substs);
         alt (fcx.ccx.unify_cache.find(cache_key)) {
             case (some[ty.Unify.result](?r)) {
@@ -947,7 +948,7 @@ tag autoderef_kind {
     NO_AUTODEREF;
 }
 
-fn strip_boxes(ty.ctxt tcx, ty.t t) -> ty.t {
+fn strip_boxes(&ty.ctxt tcx, &ty.t t) -> ty.t {
     auto t1 = t;
     while (true) {
         alt (struct(tcx, t1)) {
@@ -958,7 +959,7 @@ fn strip_boxes(ty.ctxt tcx, ty.t t) -> ty.t {
     fail;
 }
 
-fn add_boxes(@crate_ctxt ccx, uint n, ty.t t) -> ty.t {
+fn add_boxes(&@crate_ctxt ccx, uint n, &ty.t t) -> ty.t {
     auto t1 = t;
     while (n != 0u) {
         t1 = ty.mk_imm_box(ccx.tcx, t1);
@@ -968,7 +969,7 @@ fn add_boxes(@crate_ctxt ccx, uint n, ty.t t) -> ty.t {
 }
 
 
-fn count_boxes(ty.ctxt tcx, ty.t t) -> uint {
+fn count_boxes(&ty.ctxt tcx, &ty.t t) -> uint {
     auto n = 0u;
     auto t1 = t;
     while (true) {
@@ -987,12 +988,12 @@ fn count_boxes(ty.ctxt tcx, ty.t t) -> uint {
 type ty_param_substs_and_ty = tup(vec[ty.t], ty.t);
 
 mod Demand {
-    fn simple(@fn_ctxt fcx, &span sp, ty.t expected, ty.t actual) -> ty.t {
+    fn simple(&@fn_ctxt fcx, &span sp, &ty.t expected, &ty.t actual) -> ty.t {
         let vec[ty.t] tps = vec();
         ret full(fcx, sp, expected, actual, tps, NO_AUTODEREF)._1;
     }
 
-    fn autoderef(@fn_ctxt fcx, &span sp, ty.t expected, ty.t actual,
+    fn autoderef(&@fn_ctxt fcx, &span sp, &ty.t expected, &ty.t actual,
                  autoderef_kind adk) -> ty.t {
         let vec[ty.t] tps = vec();
         ret full(fcx, sp, expected, actual, tps, adk)._1;
@@ -1001,8 +1002,8 @@ mod Demand {
     // Requires that the two types unify, and prints an error message if they
     // don't. Returns the unified type and the type parameter substitutions.
 
-    fn full(@fn_ctxt fcx, &span sp, ty.t expected, ty.t actual,
-            vec[ty.t] ty_param_substs_0, autoderef_kind adk)
+    fn full(&@fn_ctxt fcx, &span sp, &ty.t expected, &ty.t actual,
+            &vec[ty.t] ty_param_substs_0, autoderef_kind adk)
             -> ty_param_substs_and_ty {
 
         auto expected_1 = expected;
@@ -1050,7 +1051,7 @@ mod Demand {
 
 
 // Returns true if the two types unify and false if they don't.
-fn are_compatible(&@fn_ctxt fcx, ty.t expected, ty.t actual) -> bool {
+fn are_compatible(&@fn_ctxt fcx, &ty.t expected, &ty.t actual) -> bool {
     alt (Unify.simple(fcx, expected, actual)) {
         case (ures_ok(_))        { ret true;  }
         case (ures_err(_, _, _)) { ret false; }
@@ -1058,8 +1059,8 @@ fn are_compatible(&@fn_ctxt fcx, ty.t expected, ty.t actual) -> bool {
 }
 
 // Returns the types of the arguments to a tag variant.
-fn variant_arg_types(@crate_ctxt ccx, &span sp, ast.def_id vid,
-                     vec[ty.t] tag_ty_params) -> vec[ty.t] {
+fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast.def_id vid,
+                     &vec[ty.t] tag_ty_params) -> vec[ty.t] {
     auto ty_param_count = Vec.len[ty.t](tag_ty_params);
 
     let vec[ty.t] result = vec();
@@ -1106,7 +1107,8 @@ mod Pushdown {
     //
     // TODO: enforce this via a predicate.
 
-    fn pushdown_pat(&@fn_ctxt fcx, ty.t expected, @ast.pat pat) -> @ast.pat {
+    fn pushdown_pat(&@fn_ctxt fcx, &ty.t expected,
+                    &@ast.pat pat) -> @ast.pat {
         auto p_1;
 
         alt (pat.node) {
@@ -1168,12 +1170,12 @@ mod Pushdown {
     // TODO: enforce this via a predicate.
     // TODO: This function is incomplete.
 
-    fn pushdown_expr(&@fn_ctxt fcx, ty.t expected, @ast.expr e)
+    fn pushdown_expr(&@fn_ctxt fcx, &ty.t expected, &@ast.expr e)
             -> @ast.expr {
         be pushdown_expr_full(fcx, expected, e, NO_AUTODEREF);
     }
 
-    fn pushdown_expr_full(&@fn_ctxt fcx, ty.t expected, @ast.expr e,
+    fn pushdown_expr_full(&@fn_ctxt fcx, &ty.t expected, &@ast.expr e,
                           autoderef_kind adk) -> @ast.expr {
         auto e_1;
 
@@ -1496,7 +1498,7 @@ mod Pushdown {
     }
 
     // Push-down over typed blocks.
-    fn pushdown_block(&@fn_ctxt fcx, ty.t expected, &ast.block bloc)
+    fn pushdown_block(&@fn_ctxt fcx, &ty.t expected, &ast.block bloc)
             -> ast.block {
         alt (bloc.node.expr) {
             case (some[@ast.expr](?e_0)) {
@@ -1598,7 +1600,7 @@ fn resolve_local_types_in_block(&@fn_ctxt fcx, &ast.block block)
 
 // AST fragment checking
 
-fn check_lit(@crate_ctxt ccx, @ast.lit lit) -> ty.t {
+fn check_lit(@crate_ctxt ccx, &@ast.lit lit) -> ty.t {
     alt (lit.node) {
         case (ast.lit_str(_))           { ret ty.mk_str(ccx.tcx); }
         case (ast.lit_char(_))          { ret ty.mk_char(ccx.tcx); }
@@ -1615,7 +1617,7 @@ fn check_lit(@crate_ctxt ccx, @ast.lit lit) -> ty.t {
     fail; // not reached
 }
 
-fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat {
+fn check_pat(&@fn_ctxt fcx, &@ast.pat pat) -> @ast.pat {
     auto new_pat;
     alt (pat.node) {
         case (ast.pat_wild(_)) {
@@ -1689,7 +1691,7 @@ fn check_pat(&@fn_ctxt fcx, @ast.pat pat) -> @ast.pat {
 }
 
 fn require_impure(&session.session sess,
-      &ast.purity f_purity, &span sp) -> () {
+                  &ast.purity f_purity, &span sp) -> () {
     alt (f_purity) {
         case (ast.impure_fn) {
             ret;
@@ -1707,7 +1709,8 @@ fn get_function_purity(@crate_ctxt ccx, &ast.def_id d_id) -> ast.purity {
 }
 
 fn require_pure_call(@crate_ctxt ccx,
-    &ast.purity caller_purity, @ast.expr callee, &span sp) -> () {
+                     &ast.purity caller_purity,
+                     &@ast.expr callee, &span sp) -> () {
     alt (caller_purity) {
         case (ast.impure_fn) {
             ret;
@@ -1744,7 +1747,7 @@ fn require_pure_function(@crate_ctxt ccx, &ast.def_id d_id, &span sp) -> () {
     }
 }
 
-fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
+fn check_expr(&@fn_ctxt fcx, &@ast.expr expr) -> @ast.expr {
     //fcx.ccx.sess.span_warn(expr.span, "typechecking expr " +
     //                       util.common.expr_to_str(expr));
 
@@ -1804,7 +1807,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
     }
 
     // A generic function for checking assignment expressions
-    fn check_assignment(&@fn_ctxt fcx, @ast.expr lhs, @ast.expr rhs)
+    fn check_assignment(&@fn_ctxt fcx, &@ast.expr lhs, &@ast.expr rhs)
         -> tup(@ast.expr, @ast.expr, ast.ann) {
         auto lhs_0 = check_expr(fcx, lhs);
         auto rhs_0 = check_expr(fcx, rhs);
@@ -1820,7 +1823,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
     }
 
     // A generic function for checking call expressions
-    fn check_call(&@fn_ctxt fcx, @ast.expr f, vec[@ast.expr] args)
+    fn check_call(&@fn_ctxt fcx, &@ast.expr f, &vec[@ast.expr] args)
         -> tup(@ast.expr, vec[@ast.expr]) {
 
         let vec[Option.t[@ast.expr]] args_opt_0 = vec();
@@ -2686,7 +2689,7 @@ fn check_expr(&@fn_ctxt fcx, @ast.expr expr) -> @ast.expr {
     }
 }
 
-fn next_ty_var(@crate_ctxt ccx) -> ty.t {
+fn next_ty_var(&@crate_ctxt ccx) -> ty.t {
     auto t = ty.mk_var(ccx.tcx, ccx.next_var_id);
     ccx.next_var_id += 1;
     ret t;
@@ -2699,7 +2702,7 @@ fn check_decl_local(&@fn_ctxt fcx, &@ast.decl decl) -> @ast.decl {
             auto t;
 
             t = ty.mk_nil(fcx.ccx.tcx);
-            
+
             alt (local.ty) {
                 case (none[@ast.ty]) {
                     // Auto slot. Do nothing for now.
@@ -2712,7 +2715,7 @@ fn check_decl_local(&@fn_ctxt fcx, &@ast.decl decl) -> @ast.decl {
                 }
             }
 
-            auto a_res = local.ann; 
+            auto a_res = local.ann;
             alt (a_res) {
                 case (ann_none) {
                     a_res = triv_ann(t);
@@ -2807,8 +2810,8 @@ fn check_block(&@fn_ctxt fcx, &ast.block block) -> ast.block {
                                     a=plain_ann(fcx.ccx.tcx)));
 }
 
-fn check_const(&@crate_ctxt ccx, &span sp, ast.ident ident, @ast.ty t,
-               @ast.expr e, ast.def_id id, ast.ann ann) -> @ast.item {
+fn check_const(&@crate_ctxt ccx, &span sp, &ast.ident ident, &@ast.ty t,
+               &@ast.expr e, &ast.def_id id, &ast.ann ann) -> @ast.item {
     // FIXME: this is kinda a kludge; we manufacture a fake "function context"
     // for checking the initializer expression.
     auto rty = ann_to_type(ann);
@@ -2858,7 +2861,7 @@ fn check_fn(&@crate_ctxt ccx, &ast.fn_decl decl, ast.proto proto,
               ccx.sess.span_err(body.span, "Non-boolean return type in pred");
             }
         }
-        case (_) {} 
+        case (_) {}
     }
 
     auto block_wb = resolve_local_types_in_block(fcx, block_t);
@@ -2894,7 +2897,7 @@ 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;
-            ret @rec(obj_fields = ob.fields, 
+            ret @rec(obj_fields = ob.fields,
                      this_obj = some[ast.def_id](di) with *ccx);
         }
         case (_) {
@@ -2935,10 +2938,10 @@ fn eq_unify_cache_entry(&unify_cache_entry a, &unify_cache_entry b) -> bool {
     ret true;
 }
 
-fn mk_fn_purity_table(@ast.crate crate) -> @fn_purity_table {
+fn mk_fn_purity_table(&@ast.crate crate) -> @fn_purity_table {
     auto res = @new_def_hash[ast.purity]();
 
-    fn do_one(@fn_purity_table t, @ast.item i) -> () {
+    fn do_one(@fn_purity_table t, &@ast.item i) -> () {
         alt (i.node) {
             case (ast.item_fn(_, ?f, _, ?d_id, _)) {
                 t.insert(d_id, f.decl.purity);
@@ -2958,8 +2961,7 @@ fn mk_fn_purity_table(@ast.crate crate) -> @fn_purity_table {
 
 type typecheck_result = tup(@ast.crate, ty.type_cache);
 
-fn check_crate(ty.ctxt tcx, @ast.crate crate)
-        -> typecheck_result {
+fn check_crate(&ty.ctxt tcx, &@ast.crate crate) -> typecheck_result {
     auto sess = tcx.sess;
     auto result = Collect.collect_item_types(sess, tcx, crate);
 
diff --git a/src/comp/middle/walk.rs b/src/comp/middle/walk.rs
index 2df69261f38..c8f5f43236e 100644
--- a/src/comp/middle/walk.rs
+++ b/src/comp/middle/walk.rs
@@ -5,28 +5,28 @@ import std.Option.some;
 import std.Option.none;
 
 type ast_visitor =
-    rec(fn () -> bool                 keep_going,
-        fn () -> bool                 want_crate_directives,
-        fn (&ast.crate c)             visit_crate_pre,
-        fn (&ast.crate c)             visit_crate_post,
-        fn (@ast.crate_directive cd)  visit_crate_directive_pre,
-        fn (@ast.crate_directive cd)  visit_crate_directive_post,
-        fn (@ast.view_item i)         visit_view_item_pre,
-        fn (@ast.view_item i)         visit_view_item_post,
-        fn (@ast.native_item i)       visit_native_item_pre,
-        fn (@ast.native_item i)       visit_native_item_post,
-        fn (@ast.item i)              visit_item_pre,
-        fn (@ast.item i)              visit_item_post,
-        fn (&ast.block b)             visit_block_pre,
-        fn (&ast.block b)             visit_block_post,
-        fn (@ast.stmt s)              visit_stmt_pre,
-        fn (@ast.stmt s)              visit_stmt_post,
-        fn (@ast.decl d)              visit_decl_pre,
-        fn (@ast.decl d)              visit_decl_post,
-        fn (@ast.expr e)              visit_expr_pre,
-        fn (@ast.expr e)              visit_expr_post,
-        fn (@ast.ty t)                visit_ty_pre,
-        fn (@ast.ty t)                visit_ty_post);
+    rec(fn () -> bool                  keep_going,
+        fn () -> bool                  want_crate_directives,
+        fn (&ast.crate c)              visit_crate_pre,
+        fn (&ast.crate c)              visit_crate_post,
+        fn (&@ast.crate_directive cd)  visit_crate_directive_pre,
+        fn (&@ast.crate_directive cd)  visit_crate_directive_post,
+        fn (&@ast.view_item i)         visit_view_item_pre,
+        fn (&@ast.view_item i)         visit_view_item_post,
+        fn (&@ast.native_item i)       visit_native_item_pre,
+        fn (&@ast.native_item i)       visit_native_item_post,
+        fn (&@ast.item i)              visit_item_pre,
+        fn (&@ast.item i)              visit_item_post,
+        fn (&ast.block b)              visit_block_pre,
+        fn (&ast.block b)              visit_block_post,
+        fn (&@ast.stmt s)              visit_stmt_pre,
+        fn (&@ast.stmt s)              visit_stmt_post,
+        fn (&@ast.decl d)              visit_decl_pre,
+        fn (&@ast.decl d)              visit_decl_post,
+        fn (&@ast.expr e)              visit_expr_pre,
+        fn (&@ast.expr e)              visit_expr_post,
+        fn (&@ast.ty t)                visit_ty_pre,
+        fn (&@ast.ty t)                visit_ty_post);
 
 fn walk_crate(&ast_visitor v, &ast.crate c) {
     if (!v.keep_going()) { ret; }
@@ -409,15 +409,15 @@ fn walk_expr(&ast_visitor v, @ast.expr e) {
 fn def_keep_going() -> bool { ret true; }
 fn def_want_crate_directives() -> bool { ret false; }
 fn def_visit_crate(&ast.crate c) { }
-fn def_visit_crate_directive(@ast.crate_directive c) { }
-fn def_visit_view_item(@ast.view_item vi) { }
-fn def_visit_native_item(@ast.native_item ni) { }
-fn def_visit_item(@ast.item i) { }
+fn def_visit_crate_directive(&@ast.crate_directive c) { }
+fn def_visit_view_item(&@ast.view_item vi) { }
+fn def_visit_native_item(&@ast.native_item ni) { }
+fn def_visit_item(&@ast.item i) { }
 fn def_visit_block(&ast.block b) { }
-fn def_visit_stmt(@ast.stmt s) { }
-fn def_visit_decl(@ast.decl d) { }
-fn def_visit_expr(@ast.expr e) { }
-fn def_visit_ty(@ast.ty t) { }
+fn def_visit_stmt(&@ast.stmt s) { }
+fn def_visit_decl(&@ast.decl d) { }
+fn def_visit_expr(&@ast.expr e) { }
+fn def_visit_ty(&@ast.ty t) { }
 
 fn default_visitor() -> ast_visitor {