Encode/decode AST into metadata, re-instantiate inlined items

33 files changed, 10674 insertions, 942 deletions

diff --git a/src/comp/driver/driver.rs b/src/comp/driver/driver.rs
index 40cf4e50472..33398722605 100644
--- a/src/comp/driver/driver.rs
+++ b/src/comp/driver/driver.rs
@@ -6,7 +6,7 @@ import syntax::parse::{parser};
 import syntax::{ast, codemap};
 import front::attr;
 import middle::{trans, resolve, freevars, kind, ty, typeck, fn_usage,
-                last_use, lint};
+                last_use, lint, inline};
 import syntax::print::{pp, pprust};
 import util::{ppaux, filesearch};
 import back::link;
@@ -157,7 +157,7 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
          bind middle::check_alt::check_crate(ty_cx, crate));
     time(time_passes, "typestate checking",
          bind middle::tstate::ck::check_crate(ty_cx, crate));
-    let mut_map =
+    let mutbl_map =
         time(time_passes, "mutability checking",
              bind middle::mutbl::check_crate(ty_cx, crate));
     let (copy_map, ref_map) =
@@ -173,12 +173,19 @@ fn compile_upto(sess: session, cfg: ast::crate_cfg,
     if upto == cu_no_trans { ret {crate: crate, tcx: some(ty_cx)}; }
     let outputs = option::get(outputs);
 
+    let maps = {mutbl_map: mutbl_map, copy_map: copy_map,
+                last_uses: last_uses, impl_map: impl_map,
+                method_map: method_map, dict_map: dict_map};
+
+    let inline_map =
+        time(time_passes, "inline",
+             bind inline::instantiate_inlines(ty_cx, maps, crate));
+
     let (llmod, link_meta) =
         time(time_passes, "translation",
              bind trans::base::trans_crate(
-                 sess, crate, ty_cx, outputs.obj_filename, exp_map, ast_map,
-                 mut_map, copy_map, last_uses, impl_map, method_map,
-                 dict_map));
+                 sess, crate, ty_cx, outputs.obj_filename,
+                 exp_map, maps, inline_map));
     time(time_passes, "LLVM passes",
          bind link::write::run_passes(sess, llmod, outputs.obj_filename));
 
diff --git a/src/comp/metadata/astencode.rs b/src/comp/metadata/astencode.rs
index 71a95506a9d..bed7494ebc1 100644
--- a/src/comp/metadata/astencode.rs
+++ b/src/comp/metadata/astencode.rs
@@ -1,653 +1,886 @@
-// Encoding of ASTs and the associated side tables.
-
-import middle::base::trans::common::crate_ctxt;
 import syntax::ast;
-import syntax::codemap::{span, filename};
+import syntax::fold;
+import syntax::visit;
+import syntax::ast_util;
+import syntax::codemap::span;
+import std::map::map;
+import std::smallintmap::map;
+import std::ebml;
 import std::ebml::writer;
-import metadata::common::*;
-
-enum ast_tag {
-    at_span,
-    at_id,
-
-    at_span_expninfo_callie_name,
-    at_span_expninfo_callie_span,
-
-    at_blk,
-    at_blk_stmts,
-    at_blk_expr,
-    at_blk_rules,
-
-    at_stmt,
-    at_stmt_node_decl,
-    at_stmt_node_expr,
-
-    at_expr,
-    at_expr_node_vec,
-    at_expr_node_rec,
-    at_expr_node_call,
-    at_expr_node_tup,
-    at_expr_node_bind,
-    at_expr_node_bind_args,
-    at_expr_node_binary,
-    at_expr_node_unary,
-    at_expr_node_lit,
-    at_expr_node_cast,
-    at_expr_node_if,
-    at_expr_node_while,
-
-    at_none,
-    at_some,
-}
-
-type ast_ctxt = {
-    embl_w: ebml::writer,
-    ccx: crate_ctxt,
+import std::serialization;
+import std::serialization::serializer;
+import std::serialization::deserializer;
+import std::serialization::serializer_helpers;
+import std::serialization::deserializer_helpers;
+import middle::trans::common::maps;
+import middle::ty;
+import middle::typeck;
+import middle::typeck::method_origin;
+import middle::typeck::dict_res;
+import middle::typeck::dict_origin;
+import middle::ast_map;
+import driver::session;
+import driver::session::session;
+import middle::freevars::freevar_entry;
+import c = common;
+import e = encoder;
+
+// used in testing:
+import std::io;
+import driver::diagnostic;
+import syntax::codemap;
+import syntax::parse::parser;
+import syntax::print::pprust;
+
+export encode_inlined_item;
+export decode_inlined_item;
+
+type decode_ctxt = @{
+    cdata: cstore::crate_metadata,
+    tcx: ty::ctxt,
+    maps: maps
 };
 
-impl ast_output for ast_ctxt {
-    fn tag(tag: ast_tag, blk: fn()) {
-        self.embl_w.wr_tag(tag as uint, blk)
-    }
+type extended_decode_ctxt = @{
+    dcx: decode_ctxt,
+    from_id_range: id_range,
+    to_id_range: id_range
+};
 
-    fn uint(v: uint) {
-        self.embl_w.wr_uint(v)
-    }
+iface tr {
+    fn tr(xcx: extended_decode_ctxt) -> self;
+}
 
-    fn opt<T>(x: option<T>, blk: fn(T)) {
-        alt x {
-          none { self.tag(at_none) {||} }
-          some(v) { self.tag(at_some) {|| blk(v) } }
-        }
+// ______________________________________________________________________
+// Enumerating the IDs which appear in an AST
+
+fn encode_inlined_item(ecx: @e::encode_ctxt,
+                       ebml_w: ebml::writer,
+                       item: @ast::item) {
+    let id_range = compute_id_range(item);
+    ebml_w.wr_tag(c::tag_ast as uint) {||
+        encode_id_range(ebml_w, id_range);
+        encode_ast(ebml_w, item);
+        encode_side_tables_for_item(ecx, ebml_w, item);
     }
+}
 
-    fn str(tag: ast_tag, v: str) {
-        self.tag(tag) {|| self.embl_w.wr_str(v) };
+fn decode_inlined_item(cdata: cstore::crate_metadata,
+                       tcx: ty::ctxt,
+                       maps: maps,
+                       path: ast_map::path,
+                       par_doc: ebml::doc) -> option<@ast::item> {
+    let dcx = @{cdata: cdata, tcx: tcx, maps: maps};
+    alt par_doc.opt_child(c::tag_ast) {
+      none { none }
+      some(ast_doc) {
+        let from_id_range = decode_id_range(ast_doc);
+        let to_id_range = reserve_id_range(dcx.tcx.sess, from_id_range);
+        let xcx = @{dcx: dcx,
+                    from_id_range: from_id_range,
+                    to_id_range: to_id_range};
+        let raw_item = decode_ast(ast_doc);
+        let item = renumber_ast(xcx, raw_item);
+        ast_map::map_decoded_item(dcx.tcx.items, path, item);
+        decode_side_tables(xcx, ast_doc);
+        some(item)
+      }
     }
+}
 
-    fn vec<T>(tag: ast_tag, v: [T], blk: fn(T)) {
-        self.tag(tag) {||
-            self.uint(vec::len(v));
-            vec::iter(v) {|e| blk(e) };
-        }
-    }
+// ______________________________________________________________________
+// Enumerating the IDs which appear in an AST
 
-    fn span(sp: span) {
-        self.tag(at_span) {||
-            self.uint(sp.lo);
-            self.uint(sp.hi);
-            self.opt(sp.expn_info) {|ei|
-                self.span(ei.call_site);
-                self.str(at_span_expninfo_callie_name, ei.callie.name);
-                self.opt(ei.callie.span) {|v| self.span(v) };
-            }
-        }
-    }
+type id_range = {min: ast::node_id, max: ast::node_id};
 
-    fn id(id: uint) {
-        self.tag(at_id) {|| self.uint(id); }
-    }
+fn empty(range: id_range) -> bool {
+    range.min >= range.max
+}
 
-    fn blk(blk: ast::blk) {
-        self.tag(at_blk) {||
-            self.id(blk.node.id);
-            self.span(blk.span);
-            self.vec(at_blk_stmts, blk.node.stmts) {|stmt|
-                self.stmt(stmt)
-            }
-            self.tag(at_blk_expr) {||
-                self.opt(blk.node.expr) {|e| self.expr(e) }
-            }
-            self.tag(at_blk_rules) {||
-                self.uint(blk.node.rules as uint);
+fn visit_ids(item: @ast::item, vfn: fn@(ast::node_id)) {
+    let visitor = visit::mk_simple_visitor(@{
+        visit_mod: fn@(_m: ast::_mod, _sp: span, id: ast::node_id) {
+            vfn(id)
+        },
+
+        visit_view_item: fn@(vi: @ast::view_item) {
+            alt vi.node {
+              ast::view_item_use(_, _, id) { vfn(id) }
+              ast::view_item_import(vps) | ast::view_item_export(vps) {
+                vec::iter(vps) {|vp|
+                    alt vp.node {
+                      ast::view_path_simple(_, _, id) { vfn(id) }
+                      ast::view_path_glob(_, id) { vfn(id) }
+                      ast::view_path_list(_, _, id) { vfn(id) }
+                    }
+                }
+              }
             }
-        }
-    }
+        },
 
-    fn decl(decl: ast::decl) {
-        self.span(decl.span);
-        alt decl.node {
-          ast::decl_local(lcls) {
-            self.vec(at_decl_local, lcls) {|lcl|
-                self.local(lcl)
-            }
-          }
+        visit_native_item: fn@(ni: @ast::native_item) {
+            vfn(ni.id)
+        },
 
-          ast::decl_item(item) {
-            self.tag(at_decl_item) {||
-                self.item(item);
-            }
-          }
-        }
-    }
+        visit_item: fn@(i: @ast::item) {
+            vfn(i.id)
+        },
 
-    fn local(lcl: ast::local) {
-        self.span(lcl.span);
-        self.ty(lcl.ty);
-        self.pat(lcl.pat);
-        self.opt(lcl.init) {|i| self.initializer(i) };
-        self.uint(lcl.id);
-    }
+        visit_local: fn@(l: @ast::local) {
+            vfn(l.node.id);
+        },
 
-    fn pat(pat: ast::pat) {
-        self.uint(pat.id);
-        self.span(pat.span);
-        alt pat_util::normalize_pat(pat.node) {
-          pat_wild {
-            self.tag(at_pat_wild) {||
-            }
-          }
-          pat_ident(path, o_pat) {
-            self.tag(at_pat_ident) {||
-                self.path(path);
-                self.opt(o_pat) {|p|
-                    self.pat(p)
-                }
-            }
-          }
-          pat_enum(path, pats) {
-            self.tag(at_pat_enum) {||
-                self.path(path);
-                self.vec(at_pat_enum_pats, pats) {|p| self.pat(p) };
+        visit_block: fn@(b: ast::blk) {
+            vfn(b.node.id);
+        },
+
+        visit_stmt: fn@(s: @ast::stmt) {
+            vfn(ast_util::stmt_id(*s));
+        },
+
+        visit_arm: fn@(_a: ast::arm) { },
+
+        visit_pat: fn@(p: @ast::pat) {
+            vfn(p.id)
+        },
+
+        visit_decl: fn@(_d: @ast::decl) {
+        },
+
+        visit_expr: fn@(e: @ast::expr) {
+            vfn(e.id);
+            alt e.node {
+              ast::expr_unary(_, _) | ast::expr_binary(_, _, _) {
+                vfn(ast_util::op_expr_callee_id(e));
+              }
+              _ { /* fallthrough */ }
             }
-          }
-          pat_rec(field_pats, b) {
-            self.tag(at_pat_rec) {||
-                self.vec(at_pat_rec_fields, field_pats) {|p|
-                    self.field_pat(p)
-                }
+        },
+
+        visit_ty: fn@(t: @ast::ty) {
+            alt t.node {
+              ast::ty_path(_, id) {
+                vfn(id)
+              }
+              _ { /* fall through */ }
             }
-          }
-          pat_tup(pats) {
-            self.vec(at_pat_tup, pats) {|p| self.pat(p); }
-          }
-          pat_box(pat) {
-            self.tag(at_pat_box) {|| self.pat(pat) }
-          }
-          pat_lit(expr) {
-            self.tag(at_pat_lit) {|| self.expr(expr) }
-          }
-          pat_range(l, h) {
-            self.tag(at_pat_range) {||
-                self.expr(l);
-                self.expr(h);
+        },
+
+        visit_ty_params: fn@(ps: [ast::ty_param]) {
+            vec::iter(ps) {|p| vfn(p.id) }
+        },
+
+        visit_constr: fn@(_p: @ast::path, _sp: span, id: ast::node_id) {
+            vfn(id);
+        },
+
+        visit_fn: fn@(fk: visit::fn_kind, _d: ast::fn_decl,
+                      _b: ast::blk, _sp: span, id: ast::node_id) {
+            vfn(id);
+
+            alt fk {
+              visit::fk_item_fn(_, tps) |
+              visit::fk_method(_, tps) |
+              visit::fk_res(_, tps) {
+                vec::iter(tps) {|tp| vfn(tp.id)}
+              }
+              visit::fk_anon(_) |
+              visit::fk_fn_block {
+              }
             }
-          }
-        }
-    }
+        },
 
-    fn stmt(stmt: ast::stmt) {
-        self.tag(at_stmt) {||
-            self.span(stmt.span);
-            alt stmt.node {
-              ast::stmt_decl(d, nid) {
-                self.id(nid);
-                self.tag(at_stmt_node_decl) {|| self.decl(d) };
+        visit_class_item: fn@(_s: span, _p: ast::privacy,
+                              c: ast::class_member) {
+            alt c {
+              ast::instance_var(_, _, _, id) {
+                vfn(id)
               }
-              ast::stmt_expr(e, nid) | ast::stmt_semi(e, nid) {
-                self.id(nid);
-                self.tag(at_stmt_node_expr) {|| self.expr(e) };
+              ast::class_method(_) {
               }
             }
         }
-    }
+    });
+
+    visitor.visit_item(item, (), visitor);
+}
 
-    fn exprs(exprs: [ast::expr]) {
-        self.vec(at_exprs, exprs) {|e| self.expr(e) };
+fn compute_id_range(item: @ast::item) -> id_range {
+    let min = @mutable int::max_value;
+    let max = @mutable int::min_value;
+    visit_ids(item) {|id|
+        *min = int::min(*min, id);
+        *max = int::max(*max, id + 1);
     }
+    ret {min:*min, max:*max};
+}
 
-    fn expr(expr: ast:expr) {
-        self.id(expr.id);
-        self.span(expr.span);
-        alt expr.node {
-          ast::expr_vec(subexprs, mutbl) {
-            self.tag(at_expr_node_vec) {||
-                self.exprs(subexprs);
-                self.mutbl(mutbl);
-            }
-          }
+fn encode_id_range(ebml_w: ebml::writer, id_range: id_range) {
+    ebml_w.wr_tag(c::tag_id_range as uint) {||
+        ebml_w.emit_tup(2u) {||
+            ebml_w.emit_tup_elt(0u) {|| ebml_w.emit_int(id_range.min) }
+            ebml_w.emit_tup_elt(1u) {|| ebml_w.emit_int(id_range.max) }
+        }
+    }
+}
 
-          ast::expr_rec(fields, opt_expr) {
-            self.tag(at_expr_node_rec) {||
-                self.fields(fields);
-                self.opt(opt_expr) {|e| self.expr(e) };
-            }
-          }
+fn decode_id_range(par_doc: ebml::doc) -> id_range {
+    let range_doc = par_doc[c::tag_id_range];
+    let dsr = serialization::mk_ebml_deserializer(range_doc);
+    dsr.read_tup(2u) {||
+        {min: dsr.read_tup_elt(0u) {|| dsr.read_int() },
+         max: dsr.read_tup_elt(1u) {|| dsr.read_int() }}
+    }
+}
 
-          ast::expr_call(func, args, _) {
-            self.tag(at_expr_node_call) {||
-                self.expr(func);
-                self.exprs(args);
-            }
-          }
+fn reserve_id_range(sess: session::session,
+                    from_id_range: id_range) -> id_range {
+    // Handle the case of an empty range:
+    if empty(from_id_range) { ret from_id_range; }
+    let cnt = from_id_range.max - from_id_range.min;
+    let to_id_min = sess.parse_sess.next_id;
+    let to_id_max = sess.parse_sess.next_id + cnt;
+    sess.parse_sess.next_id = to_id_max;
+    ret {min: to_id_min, max: to_id_min};
+}
 
-          ast::expr_tup(exprs) {
-            self.tag(at_expr_node_tup) {||
-                self.exprs(exprs);
-            }
-          }
+impl translation_routines for extended_decode_ctxt {
+    fn tr_id(id: ast::node_id) -> ast::node_id {
+        // from_id_range should be non-empty
+        assert !empty(self.from_id_range);
+        (id - self.from_id_range.min + self.to_id_range.min)
+    }
+    fn tr_def_id(did: ast::def_id) -> ast::def_id {
+        decoder::translate_def_id(self.dcx.cdata, did)
+    }
+    fn tr_intern_def_id(did: ast::def_id) -> ast::def_id {
+        assert did.crate == ast::local_crate;
+        {crate: ast::local_crate, node: self.tr_id(did.node)}
+    }
+    fn tr_span(_span: span) -> span {
+        ast_util::dummy_sp() // TODO...
+    }
+}
 
-          ast::expr_bind(f, args) {
-            self.tag(at_expr_node_bind) {||
-                self.expr(f);
-                self.vec(at_expr_node_bind_args, args) {|opt_e|
-                    self.opt(opt_e) {|e| self.expr(e)};
-                }
-            }
-          }
+impl of tr for ast::def_id {
+    fn tr(xcx: extended_decode_ctxt) -> ast::def_id {
+        xcx.tr_def_id(self)
+    }
+    fn tr_intern(xcx: extended_decode_ctxt) -> ast::def_id {
+        xcx.tr_intern_def_id(self)
+    }
+}
 
-          ast::expr_binary(binop, l, r) {
-            self.tag(at_expr_node_binary) {||
-                self.uint(binop as uint);
-                self.expr(l);
-                self.expr(r);
-            }
-          }
+impl of tr for span {
+    fn tr(xcx: extended_decode_ctxt) -> span {
+        xcx.tr_span(self)
+    }
+}
 
-          ast::expr_unary(unop, l, r) {
-            self.tag(at_expr_node_unary) {||
-                self.uint(unop as uint);
-                self.expr(l);
-                self.expr(r);
-            }
-          }
+impl serializer_helpers<S: serialization::serializer> for S {
+    fn emit_def_id(did: ast::def_id) {
+        astencode_gen::serialize_syntax_ast_def_id(self, did)
+    }
+}
 
-          ast::expr_lit(lit) {
-            self.tag(at_expr_node_lit) {|| self.lit(lit) }
-          }
+impl deserializer_helpers<D: serialization::deserializer> for D {
+    fn read_def_id(xcx: extended_decode_ctxt) -> ast::def_id {
+        let did = astencode_gen::deserialize_syntax_ast_def_id(self);
+        did.tr(xcx)
+    }
+}
 
-          ast::expr_cast(expr, ty) {
-            self.tag(at_expr_node_cast) {||
-                self.expr(expr);
-                self.ty(ty);
-            }
-          }
+// ______________________________________________________________________
+// Encoding and decoding the AST itself
+//
+// The hard work is done by an autogenerated module astencode_gen.  To
+// regenerate astencode_gen, run src/etc/gen-astencode.  It will
+// replace astencode_gen with a dummy file and regenerate its
+// contents.  If you get compile errors, the dummy file
+// remains---resolve the errors and then rerun astencode_gen.
+// Annoying, I know, but hopefully only temporary.
+//
+// When decoding, we have to renumber the AST so that the node ids that
+// appear within are disjoint from the node ids in our existing ASTs.
+// We also have to adjust the spans: for now we just insert a dummy span,
+// but eventually we should add entries to the local codemap as required.
+
+fn encode_ast(ebml_w: ebml::writer, item: @ast::item) {
+    ebml_w.wr_tag(c::tag_tree as uint) {||
+        astencode_gen::serialize_syntax_ast_item(ebml_w, *item);
+    }
+}
 
-          ast::expr_if(cond, blk_then, o_blk_else) {
-            self.tag(at_expr_node_if) {||
-                self.expr(cond);
-                self.blk(blk_then);
-                self.opt(o_blk_else) {|b| self.blk(b)};
-            }
-          }
+fn decode_ast(par_doc: ebml::doc) -> @ast::item {
+    let chi_doc = par_doc[c::tag_tree];
+    let d = serialization::mk_ebml_deserializer(chi_doc);
+    @astencode_gen::deserialize_syntax_ast_item(d)
+}
 
-          ast::expr_while(cond, blk) {
-            self.tag(at_expr_node_while) {||
-                self.expr(cond);
-                self.blk(blk);
-            }
-          }
+fn renumber_ast(xcx: extended_decode_ctxt, item: @ast::item) -> @ast::item {
+    let fld = fold::make_fold({
+        new_id: xcx.tr_id(_),
+        new_span: xcx.tr_span(_)
+        with *fold::default_ast_fold()
+    });
+    fld.fold_item(item)
+}
 
-          ast::expr_for(lcl, expr, blk) {
-            self.tag(at_expr_node_for) {||
-                self.local(lcl);
-                self.expr(expr);
-                self.blk(blk);
-            }
-          }
+// ______________________________________________________________________
+// Encoding and decoding of ast::def
 
-          ast::expr_do_while(blk, cond) {
-            self.tag(at_expr_node_do_while) {||
-                self.blk(blk);
-                self.expr(cond);
-            }
-          }
+fn encode_def(ebml_w: ebml::writer, def: ast::def) {
+    astencode_gen::serialize_syntax_ast_def(ebml_w, def)
+}
 
-          ast::expr_alt(cond, arms, _) {
-            self.tag(at_expr_node_alt) {||
-                self.blk(blk);
-                self.expr(cond);
-            }
-          }
+fn decode_def(xcx: extended_decode_ctxt, doc: ebml::doc) -> ast::def {
+    let dsr = serialization::mk_ebml_deserializer(doc);
+    let def = astencode_gen::deserialize_syntax_ast_def(dsr);
+    def.tr(xcx)
+}
 
-          ast::expr_block(blk) {
-            self.tag(at_expr_node_blk) {||
-                self.blk(blk);
-            }
+impl of tr for ast::def {
+    fn tr(xcx: extended_decode_ctxt) -> ast::def {
+        alt self {
+          ast::def_fn(did, p) { ast::def_fn(did.tr(xcx), p) }
+          ast::def_self(did) { ast::def_self(did.tr(xcx)) }
+          ast::def_mod(did) { ast::def_mod(did.tr(xcx)) }
+          ast::def_native_mod(did) { ast::def_native_mod(did.tr(xcx)) }
+          ast::def_const(did) { ast::def_const(did.tr(xcx)) }
+          ast::def_arg(did, m) { ast::def_arg(did.tr_intern(xcx), m) }
+          ast::def_local(did) { ast::def_local(did.tr_intern(xcx)) }
+          ast::def_variant(e_did, v_did) {
+            ast::def_variant(e_did.tr(xcx), v_did.tr(xcx))
+          }
+          ast::def_ty(did) { ast::def_ty(did.tr(xcx)) }
+          ast::def_prim_ty(p) { ast::def_prim_ty(p) }
+          ast::def_ty_param(did, v) { ast::def_ty_param(did.tr(xcx), v) }
+          ast::def_binding(did) { ast::def_binding(did.tr(xcx)) }
+          ast::def_use(did) { ast::def_use(did.tr(xcx)) }
+          ast::def_upvar(did, def, node_id) {
+            ast::def_upvar(did.tr_intern(xcx),
+                           @(*def).tr(xcx),
+                           xcx.tr_id(node_id))
+          }
+          ast::def_class(did) {
+            ast::def_class(did.tr(xcx))
+          }
+          ast::def_class_field(did0, did1) {
+            ast::def_class_field(did0.tr(xcx), did1.tr(xcx))
+          }
+          ast::def_class_method(did0, did1) {
+            ast::def_class_method(did0.tr(xcx), did1.tr(xcx))
           }
+        }
+    }
+}
 
-          ast::expr_copy(expr) {
-            self.tag(at_expr_node_copy) {||
-                self.expr(expr);
-            }
-          }
+// ______________________________________________________________________
+// Encoding and decoding of freevar information
 
-          ast::expr_move(l, r) {
-            self.tag(at_expr_node_move) {||
-                self.expr(l);
-                self.expr(r);
-            }
-          }
+fn encode_freevar_entry(ebml_w: ebml::writer, fv: freevar_entry) {
+    astencode_gen::serialize_middle_freevars_freevar_entry(ebml_w, fv)
+}
 
-          ast::expr_assign(l, r) {
-            self.tag(at_expr_node_assign) {||
-                self.expr(l);
-                self.expr(r);
-            }
-          }
+impl helper for serialization::ebml_deserializer {
+    fn read_freevar_entry(xcx: extended_decode_ctxt) -> freevar_entry {
+        let fv =
+            astencode_gen::deserialize_middle_freevars_freevar_entry(self);
+        fv.tr(xcx)
+    }
+}
 
-          ast::expr_swap(l, r) {
-            self.tag(at_expr_node_swap) {||
-                self.expr(l);
-                self.expr(r);
-            }
-          }
+impl of tr for freevar_entry {
+    fn tr(xcx: extended_decode_ctxt) -> freevar_entry {
+        {def: self.def.tr(xcx), span: self.span.tr(xcx)}
+    }
+}
 
-          ast::expr_assign_of(binop, l, r) {
-            self.tag(at_expr_node_assign_op) {||
-                self.uint(binop as uint);
-                self.expr(l);
-                self.expr(r);
-            }
-          }
+// ______________________________________________________________________
+// Encoding and decoding of method_origin
 
-          ast::expr_field(base, f, tys) {
-            self.tag(at_expr_node_field) {||
-                self.expr(base);
-                self.str(at_ident, f);
-                self.vec(at_tys) {|v| self.ty(v) }
-            }
-          }
+fn encode_method_origin(ebml_w: ebml::writer, mo: method_origin) {
+    astencode_gen::serialize_middle_typeck_method_origin(ebml_w, mo)
+}
 
-          ast::expr_index(l, r) {
-            self.tag(at_expr_node_index) {||
-                self.expr(l);
-                self.expr(r);
-            }
-          }
+impl helper for serialization::ebml_deserializer {
+    fn read_method_origin(xcx: extended_decode_ctxt) -> method_origin {
+        let fv = astencode_gen::deserialize_middle_typeck_method_origin(self);
+        fv.tr(xcx)
+    }
+}
 
-          ast::expr_path(pth) {
-            self.tag(at_expr_node_path) {||
-            }
+impl of tr for method_origin {
+    fn tr(xcx: extended_decode_ctxt) -> method_origin {
+        alt self {
+          typeck::method_static(did) {
+            typeck::method_static(did.tr(xcx))
           }
-
-          ast::expr_fail(o_expr) {
-            self.tag(at_expr_node_fail) {||
-                self.opt(o_expr) {|e| self.expr(e) }
-            }
+          typeck::method_param(did, m, p, b) {
+            typeck::method_param(did.tr(xcx), m, p, b)
           }
-
-          ast::expr_break {
-            self.tag(at_expr_node_break) {||}
+          typeck::method_iface(did, m) {
+            typeck::method_iface(did.tr(xcx), m)
           }
+        }
+    }
+}
 
-          ast::expr_cont {
-            self.tag(at_expr_node_cont) {||}
-          }
+// ______________________________________________________________________
+// Encoding and decoding dict_res
+
+fn encode_dict_res(ecx: @e::encode_ctxt,
+                   ebml_w: ebml::writer,
+                   dr: typeck::dict_res) {
+    // can't autogenerate this code because automatic serialization of
+    // ty::t doesn't work, and there is no way (atm) to have
+    // hand-written serialization routines combine with auto-generated
+    // ones.  perhaps we should fix this.
+    ebml_w.emit_from_vec(*dr) {|dict_origin|
+        encode_dict_origin(ecx, ebml_w, dict_origin)
+    }
+}
 
-          ast::expr_ret(o_expr) {
-            self.tag(at_expr_node_ret) {||
-                self.opt(o_expr) {|e| self.expr(e) }
+fn encode_dict_origin(ecx: @e::encode_ctxt,
+                      ebml_w: ebml::writer,
+                      dict_origin: typeck::dict_origin) {
+    ebml_w.emit_enum("dict_origin") {||
+        alt dict_origin {
+          typeck::dict_static(def_id, tys, dict_res) {
+            ebml_w.emit_enum_variant("dict_static", 0u, 3u) {||
+                ebml_w.emit_enum_variant_arg(0u) {||
+                    ebml_w.emit_def_id(def_id)
+                }
+                ebml_w.emit_enum_variant_arg(1u) {||
+                    ebml_w.emit_tys(ecx, tys);
+                }
+                ebml_w.emit_enum_variant_arg(2u) {||
+                    encode_dict_res(ecx, ebml_w, dict_res);
+                }
             }
           }
-
-          ast::expr_be(expr) {
-            self.tag(at_expr_node_be) {||
-                self.expr(expr)
+          typeck::dict_param(pn, bn) {
+            ebml_w.emit_enum_variant("dict_param", 1u, 2u) {||
+                ebml_w.emit_enum_variant_arg(0u) {||
+                    ebml_w.emit_uint(pn);
+                }
+                ebml_w.emit_enum_variant_arg(1u) {||
+                    ebml_w.emit_uint(bn);
+                }
             }
           }
-
-          ast::expr_log(i, e1, e2) {
-            self.tag(at_expr_node_log) {||
-                self.uint(i);
-                self.expr(e1);
-                self.expr(e2);
+          typeck::dict_iface(def_id) {
+            ebml_w.emit_enum_variant("dict_iface", 1u, 3u) {||
+                ebml_w.emit_enum_variant_arg(0u) {||
+                    ebml_w.emit_def_id(def_id)
+                }
             }
           }
+        }
+    }
 
-          ast::expr_assert(e) {
-            self.tag(at_expr_node_assert) {||
-                self.expr(e);
-            }
-          }
+}
 
-          ast::expr_check(mode, e) {
-            self.tag(at_expr_node_check) {||
-                self.uint(mode as uint);
-                self.expr(e);
-            }
-          }
+impl helpers for serialization::ebml_deserializer {
+    fn read_dict_res(xcx: extended_decode_ctxt) -> typeck::dict_res {
+        @self.read_to_vec {|| self.read_dict_origin(xcx) }
+    }
 
-          ast::expr_if_check(cond, b, e) {
-            self.tag(at_expr_node_if_check) {||
-                self.expr(cond);
-                self.blk(b);
-                self.opt(e) {|e| self.blk(e)};
+    fn read_dict_origin(xcx: extended_decode_ctxt) -> typeck::dict_origin {
+        self.read_enum("dict_origin") {||
+            self.read_enum_variant {|i|
+                alt check i {
+                  0u {
+                    typeck::dict_static(
+                        self.read_enum_variant_arg(0u) {||
+                            self.read_def_id(xcx)
+                        },
+                        self.read_enum_variant_arg(1u) {||
+                            self.read_tys(xcx)
+                        },
+                        self.read_enum_variant_arg(2u) {||
+                            self.read_dict_res(xcx)
+                        }
+                    )
+                  }
+                  1u {
+                    typeck::dict_param(
+                        self.read_enum_variant_arg(0u) {||
+                            self.read_uint()
+                        },
+                        self.read_enum_variant_arg(1u) {||
+                            self.read_uint()
+                        }
+                    )
+                  }
+                  2u {
+                    typeck::dict_iface(
+                        self.read_enum_variant_arg(0u) {||
+                            self.read_def_id(xcx)
+                        }
+                    )
+                  }
+                }
             }
-          }
+        }
+    }
+}
 
-          ast::expr_mac(m) {
-            self.tag(at_expr_node_mac) {||
-                /* todo */
-            }
-          }
+// ______________________________________________________________________
+// Encoding and decoding the side tables
+
+impl helpers for @e::encode_ctxt {
+    fn ty_str_ctxt() -> @tyencode::ctxt {
+        @{ds: e::def_to_str,
+          tcx: self.ccx.tcx,
+          abbrevs: tyencode::ac_use_abbrevs(self.type_abbrevs)}
+    }
+}
+
+impl helpers for ebml::writer {
+    fn emit_ty(ecx: @e::encode_ctxt, ty: ty::t) {
+        e::write_type(ecx, self, ty)
+    }
+
+    fn emit_tys(ecx: @e::encode_ctxt, tys: [ty::t]) {
+        self.emit_from_vec(tys) {|ty|
+            e::write_type(ecx, self, ty)
         }
     }
 
-    fn lit(l: ast::lit) {
-        alt l {
-          lit_str(s) {
-            self.str(at_lit_str, s);
-          }
-          lit_int(i, t) {
-            self.tag(at_lit_int) {||
-                self.i64(i);
-                self.int_ty(t);
-            }
-          }
-          lit_uint(i, t) {
-            self.tag(at_lit_uint) {||
-                self.u64(i);
-                self.uint_ty(t);
+    fn emit_bounds(ecx: @e::encode_ctxt, bs: ty::param_bounds) {
+        tyencode::enc_bounds(self.writer, ecx.ty_str_ctxt(), bs)
+    }
+
+    fn emit_tpbt(ecx: @e::encode_ctxt, tpbt: ty::ty_param_bounds_and_ty) {
+        self.emit_rec {||
+            self.emit_rec_field("bounds", 0u) {||
+                self.emit_from_vec(*tpbt.bounds) {|bs|
+                    self.emit_bounds(ecx, bs)
+                }
             }
-          }
-          lit_float(s, f) {
-            self.tag(at_lit_float) {||
-                self.str(at_value, s);
-                self.float_ty(f);
+            self.emit_rec_field("ty", 0u) {||
+                self.emit_ty(ecx, tpbt.ty);
             }
-          }
-          lit_nil {
-            self.tag(at_lit_nil) {||}
-          }
-          lit_bool(true) {
-            self.tag(at_lit_true) {||}
-          }
-          lit_bool(false) {
-            self.tag(at_lit_false) {||}
-          }
         }
     }
+}
 
-    fn int_ty(t: ast::int_ty) {
-        self.uint(t as uint);
+impl writer for ebml::writer {
+    fn tag(tag_id: c::astencode_tag, f: fn()) {
+        self.wr_tag(tag_id as uint) {|| f() }
     }
 
-    fn uint_ty(t: ast::uint_ty) {
-        self.uint(t as uint);
+    fn id(id: ast::node_id) {
+        self.wr_tagged_u64(c::tag_table_id as uint, id as u64)
     }
+}
 
-    fn float_ty(t: ast::float_ty) {
-        self.uint(t as uint);
+fn encode_side_tables_for_item(ecx: @e::encode_ctxt,
+                               ebml_w: ebml::writer,
+                               item: @ast::item) {
+    ebml_w.wr_tag(c::tag_table as uint) {||
+        visit_ids(item, fn@(id: ast::node_id) {
+            // Note: this will cause a copy of ebml_w, which is bad as
+            // it has mutable fields.  But I believe it's harmless since
+            // we generate balanced EBML.
+            encode_side_tables_for_id(ecx, ebml_w, id)
+        });
     }
+}
 
-    fn ty(ty: ast::ty) {
-        self.tag(at_ty) {||
-            self.span(ty.span);
-            alt ty.node {
-              ty_nil {
-                self.tag(at_ty_nil) {||}
-              }
+fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
+                             ebml_w: ebml::writer,
+                             id: ast::node_id) {
 
-              ty_bot {
-                self.tag(at_ty_bot) {||}
-              }
+    let ccx = ecx.ccx;
+    let tcx = ccx.tcx;
 
-              ty_box({ty: ty, mutbl: m}) {
-                self.tag(at_ty_box) {||
-                    self.ty(ty);
-                    self.mutbl(m);
-                }
-              }
+    #debug["Encoding side tables for id %d", id];
 
-              ty_uniq({ty: ty, mutbl: m}) {
-                self.tag(at_ty_uniq) {||
-                    self.ty(ty);
-                    self.mutbl(m);
-                }
-              }
+    option::may(tcx.def_map.find(id)) {|def|
+        ebml_w.tag(c::tag_table_def) {||
+            ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val) {||
+                astencode_gen::serialize_syntax_ast_def(ebml_w, def)
+            }
+        }
+    }
+    option::may((*tcx.node_types).find(id as uint)) {|ty|
+        ebml_w.tag(c::tag_table_node_type) {||
+            ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val) {||
+                e::write_type(ecx, ebml_w, ty)
+            }
+        }
+    }
 
-              ty_vec({ty: ty, mutbl: m}) {
-                self.tag(at_ty_vec) {||
-                    self.ty(ty);
-                    self.mutbl(m);
-                }
-              }
+    option::may(tcx.node_type_substs.find(id)) {|tys|
+        ebml_w.tag(c::tag_table_node_type_subst) {||
+            ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val) {||
+                ebml_w.emit_tys(ecx, tys)
+            }
+        }
+    }
 
-              ty_ptr({ty: ty, mutbl: m}) {
-                self.tag(at_ty_ptr) {||
-                    self.ty(ty);
-                    self.mutbl(m);
+    option::may(tcx.freevars.find(id)) {|fv|
+        ebml_w.tag(c::tag_table_freevars) {||
+            ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val) {||
+                ebml_w.emit_from_vec(*fv) {|fv_entry|
+                    encode_def(ebml_w, fv_entry.def);
                 }
-              }
+            }
+        }
+    }
 
-              ty_rec(fields) {
-                self.vec(at_ty_rec) {|f|
-                    self.field(f)
-                }
-              }
+    let lid = {crate: ast::local_crate, node: id};
+    option::may(tcx.tcache.find(lid)) {|tpbt|
+        ebml_w.tag(c::tag_table_tcache) {||
+            ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val) {||
+                ebml_w.emit_tpbt(ecx, tpbt);
+            }
+        }
+    }
 
-              ty_fn(proto, fd) {
-                self.tag(at_ty_fn) {||
-                    self.uint(proto as uint);
-                    self.fn_decl(fd)
-                }
-              }
+    option::may(tcx.ty_param_bounds.find(id)) {|pbs|
+        ebml_w.tag(c::tag_table_param_bounds) {||
+            ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val) {||
+                ebml_w.emit_bounds(ecx, pbs)
+            }
+        }
+    }
 
-              ty_tup(tys) {
-                self.vec(at_ty_tups) {|ty| self.ty(ty)}
-              }
+    // I believe it is not necessary to encode this information.  The
+    // ids will appear in the AST but in the *type* information, which
+    // is what we actually use in trans, all modes will have been
+    // resolved.
+    //
+    //option::may(tcx.inferred_modes.find(id)) {|m|
+    //    ebml_w.tag(c::tag_table_inferred_modes) {||
+    //        ebml_w.id(id);
+    //        ebml_w.tag(c::tag_table_val) {||
+    //            tyencode::enc_mode(ebml_w.writer, ty_str_ctxt(), m);
+    //        }
+    //    }
+    //}
+
+    option::may(ccx.maps.mutbl_map.find(id)) {|_m|
+        ebml_w.tag(c::tag_table_mutbl) {||
+            ebml_w.id(id);
+        }
+    }
 
-              ty_path(p, id) {
-                self.tag(at_ty_path) {||
-                    self.path(p);
-                    self.uint(id);
-                }
-              }
+    option::may(ccx.maps.copy_map.find(id)) {|_m|
+        ebml_w.tag(c::tag_table_copy) {||
+            ebml_w.id(id);
+        }
+    }
 
-              ty_constr(t, tcs) {
-                self.tag(at_ty_constr) {||
-                    self.ty(t);
-                    // ... constrs ... who cares ...
-                }
-              }
+    option::may(ccx.maps.last_uses.find(id)) {|_m|
+        ebml_w.tag(c::tag_table_last_use) {||
+            ebml_w.id(id);
+        }
+    }
 
-              ty_mac(m) {
-                self.tag(at_ty_mac) {||
-                    self.mac(m);
-                };
-              }
+    // impl_map is not used except when emitting metadata,
+    // don't need to keep it.
 
-              ty_infer {
-                self.tag(at_ty_infer) {||
-                }
-              }
+    option::may(ccx.maps.method_map.find(id)) {|mo|
+        ebml_w.tag(c::tag_table_method_map) {||
+            ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val) {||
+                astencode_gen::
+                    serialize_middle_typeck_method_origin(ebml_w, mo)
             }
         }
     }
 
-    fn item(item: @ast::item) {
-        self.tag(at_item) {||
-            self.str(at_item_ident, item);
-            self.vec(at_item_attrs, item.attrs) {|a| self.attr(a)}
-            self.uint(item.id);
-            self.span(item.span);
-
-            alt item.node {
-              item_const(t, e) {
-                self.tag(at_item_const) {||
-                    self.ty(t);
-                    self.expr(e);
-                }
-              }
-              item_fn(d, tps, blk) {
-                self.tag(at_item_fn) {||
-                    self.fn_decl(d);
-                    self.ty_params(tps);
-                }
-              }
-              item_mod(m) {
-                self.tag(at_item_mod) {||
-                    self.mod_(m)
-                }
-              }
-              item_native_mod(nm) {
-                self.tag(at_item_native_mod) {||
-                    self.mod_(nm)
-                }
-              }
-              item_ty(ty, tps) {
-                self.tag(at_item_ty) {||
-                    self.ty(ty);
-                    self.ty_params(tps);
-                }
-              }
-              item_enum(variants, tps) {
-                self.tag(at_item_enum) {||
-                    self.ty(ty);
-                    self.ty_params(tps);
-                }
-              }
-              item_res(fd, tps, blk, node_id, node_id) {
-                self.tag(at_item_res) {||
-                    self.fn_decl(fd);
-                    self.ty_params(tps);
-                }
-              }
-              item_class(tps, citems, fn_decl, blk) {
-                self.tag(at_item_class) {||
-                    self.ty_params(tps);
-                    self.class_items(citems);
-                    self.fn_decl(fn_decl);
-                    self.blk(blk);
-                }
-              }
-              item_iface(tps, tms) {
-                self.tag(at_item_iface) {||
-                    self.ty_params(tps);
-                    self.ty_methods(tms);
-                }
-              }
-              item_impl(tps, iface_ty, self_ty, mthds) {
-                self.tag(at_item_impl) {||
-                    self.ty_params(tps);
-                    self.opt(iface_ty) {|t| self.ty(t) };
-                    self.ty(self_ty);
-                    self.methods(mthds);
-                }
-              }
+    option::may(ccx.maps.dict_map.find(id)) {|dr|
+        ebml_w.tag(c::tag_table_dict_map) {||
+            ebml_w.id(id);
+            ebml_w.tag(c::tag_table_val) {||
+                encode_dict_res(ecx, ebml_w, dr);
             }
         }
     }
+}
 
-    fn ty_params(tps: [ast::ty_param]) {
-        self.vec(at_item_tps, tps) {|t| self.ty_param(t) }
+impl decoder for ebml::doc {
+    fn as_int() -> int { ebml::doc_as_u64(self) as int }
+    fn [](tag: c::astencode_tag) -> ebml::doc {
+        ebml::get_doc(self, tag as uint)
+    }
+    fn opt_child(tag: c::astencode_tag) -> option<ebml::doc> {
+        ebml::maybe_get_doc(self, tag as uint)
     }
+}
 
-    fn ty_param(tp: ast::ty_param) {
-        self.str(at_ty_param_ident, tp.ident);
-        self.uint(at_ty_param_id, tp.id);
-        self.vec(at_param_bounds, *tp.bounds) {|b| self.ty_param_bound(b) };
+impl decoder for serialization::ebml_deserializer {
+    fn read_ty(xcx: extended_decode_ctxt) -> ty::t {
+        tydecode::parse_ty_data(
+            self.parent.data, xcx.dcx.cdata.cnum, self.pos, xcx.dcx.tcx,
+            xcx.tr_def_id(_))
     }
 
-    fn ty_param_bound(b: ast::ty_param_bound) {
-        alt b {
-          bound_copy { self.tag(at_ty_param_bound_copy) {||} }
-          bound_send { self.tag(at_ty_param_bound_send) {||} }
-          bound_iface(t) {
-            self.tag(at_ty_param_bound_iface) {|| self.ty(t) }
-          }
+    fn read_tys(xcx: extended_decode_ctxt) -> [ty::t] {
+        self.read_to_vec {|| self.read_ty(xcx) }
+    }
+
+    fn read_bounds(xcx: extended_decode_ctxt) -> @[ty::param_bound] {
+        tydecode::parse_bounds_data(
+            self.parent.data, self.pos, xcx.dcx.cdata.cnum, xcx.dcx.tcx,
+            xcx.tr_def_id(_))
+    }
+
+    fn read_ty_param_bounds_and_ty(xcx: extended_decode_ctxt)
+        -> ty::ty_param_bounds_and_ty {
+        self.read_rec {||
+            {
+                bounds: self.read_rec_field("bounds", 0u) {||
+                    @self.read_to_vec {|| self.read_bounds(xcx) }
+                },
+                ty: self.read_rec_field("ty", 1u) {||
+                    self.read_ty(xcx)
+                }
+            }
+        }
+    }
+}
+
+fn decode_side_tables(xcx: extended_decode_ctxt,
+                      ast_doc: ebml::doc) {
+    let dcx = xcx.dcx;
+    let tbl_doc = ast_doc[c::tag_table];
+    ebml::docs(tbl_doc) {|tag, entry_doc|
+        let id0 = entry_doc[c::tag_table_id].as_int();
+        let id = xcx.tr_id(id0);
+
+        #debug["side table document with tag 0x%x found for id %d (orig %d)",
+               tag, id, id0];
+
+        if tag == (c::tag_table_mutbl as uint) {
+            dcx.maps.mutbl_map.insert(id, ());
+        } else if tag == (c::tag_table_copy as uint) {
+            dcx.maps.copy_map.insert(id, ());
+        } else if tag == (c::tag_table_last_use as uint) {
+            dcx.maps.last_uses.insert(id, ());
+        } else {
+            let val_doc = entry_doc[c::tag_table_val];
+            let val_dsr = serialization::mk_ebml_deserializer(val_doc);
+            if tag == (c::tag_table_def as uint) {
+                let def = decode_def(xcx, val_doc);
+                dcx.tcx.def_map.insert(id, def);
+            } else if tag == (c::tag_table_node_type as uint) {
+                let ty = val_dsr.read_ty(xcx);
+                (*dcx.tcx.node_types).insert(id as uint, ty);
+            } else if tag == (c::tag_table_node_type_subst as uint) {
+                let tys = val_dsr.read_tys(xcx);
+                dcx.tcx.node_type_substs.insert(id, tys);
+            } else if tag == (c::tag_table_freevars as uint) {
+                let fv_info = @val_dsr.read_to_vec {||
+                    @val_dsr.read_freevar_entry(xcx)
+                };
+                dcx.tcx.freevars.insert(id, fv_info);
+            } else if tag == (c::tag_table_tcache as uint) {
+                let tpbt = val_dsr.read_ty_param_bounds_and_ty(xcx);
+                let lid = {crate: ast::local_crate, node: id};
+                dcx.tcx.tcache.insert(lid, tpbt);
+            } else if tag == (c::tag_table_param_bounds as uint) {
+                let bounds = val_dsr.read_bounds(xcx);
+                dcx.tcx.ty_param_bounds.insert(id, bounds);
+            } else if tag == (c::tag_table_method_map as uint) {
+                dcx.maps.method_map.insert(id,
+                                           val_dsr.read_method_origin(xcx));
+            } else if tag == (c::tag_table_dict_map as uint) {
+                dcx.maps.dict_map.insert(id,
+                                         val_dsr.read_dict_res(xcx));
+            } else {
+                xcx.dcx.tcx.sess.bug(
+                    #fmt["Unknown tag found in side tables: %x", tag]);
+            }
         }
     }
 }
 
+// ______________________________________________________________________
+// Testing
+
+#[cfg(test)]
+fn new_parse_sess() -> parser::parse_sess {
+    let cm = codemap::new_codemap();
+    let handler = diagnostic::mk_handler(option::none);
+    let sess = @{
+        cm: cm,
+        mutable next_id: 1,
+        span_diagnostic: diagnostic::mk_span_handler(handler, cm),
+        mutable chpos: 0u,
+        mutable byte_pos: 0u
+    };
+    ret sess;
+}
+
+#[cfg(test)]
+iface fake_ext_ctxt {
+    fn session() -> fake_session;
+}
+
+#[cfg(test)]
+type fake_options = {cfg: ast::crate_cfg};
+
+#[cfg(test)]
+type fake_session = {opts: @fake_options,
+                     parse_sess: parser::parse_sess};
+
+#[cfg(test)]
+impl of fake_ext_ctxt for fake_session {
+    fn session() -> fake_session {self}
+}
+
+#[cfg(test)]
+fn mk_ctxt() -> fake_ext_ctxt {
+    let opts : fake_options = {cfg: []};
+    {opts: @opts, parse_sess: new_parse_sess()} as fake_ext_ctxt
+}
+
+#[cfg(test)]
+fn roundtrip(in_item: @ast::item) {
+    #debug["in_item = %s", pprust::item_to_str(in_item)];
+    let mbuf = io::mk_mem_buffer();
+    let ebml_w = ebml::mk_writer(io::mem_buffer_writer(mbuf));
+    encode_ast(ebml_w, in_item);
+    let ebml_doc = ebml::new_doc(@io::mem_buffer_buf(mbuf));
+    let out_item = decode_ast(ebml_doc);
+    #debug["out_item = %s", pprust::item_to_str(out_item)];
+    assert in_item == out_item;
+}
+
+#[test]
+fn test_basic() {
+    let ext_cx = mk_ctxt();
+    roundtrip(#ast(item){
+        fn foo() {}
+    });
+}
+
+#[test]
+fn test_smalltalk() {
+    let ext_cx = mk_ctxt();
+    roundtrip(#ast(item){
+        fn foo() -> int { 3 + 4 } // first smalltalk program ever executed.
+    });
+}
+
+#[test]
+fn test_more() {
+    let ext_cx = mk_ctxt();
+    roundtrip(#ast(item){
+        fn foo(x: uint, y: uint) -> uint {
+            let z = x + y;
+            ret z;
+        }
+    });
+}
\ No newline at end of file
diff --git a/src/comp/metadata/astencode_gen.rs b/src/comp/metadata/astencode_gen.rs
new file mode 100644
index 00000000000..faa76cc99ed
--- /dev/null
+++ b/src/comp/metadata/astencode_gen.rs
@@ -0,0 +1,8734 @@
+/*syntax::ast::ident*/
+fn serialize_1<S: std::serialization::serializer>(s: S,
+                                                  v: syntax::ast::ident) {
+
+    s.emit_str(v);
+}
+/*syntax::ast::attr_style*/
+fn serialize_5<S: std::serialization::serializer>(s: S,
+                                                  v:
+                                                      syntax::ast::attr_style) {
+    s.emit_enum("syntax::ast::attr_style",
+
+                {||
+                    alt v {
+                      syntax::ast::attr_outer {
+                        s.emit_enum_variant("syntax::ast::attr_outer", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::attr_inner {
+                        s.emit_enum_variant("syntax::ast::attr_inner", 1u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*@syntax::ast::meta_item*/
+fn serialize_9<S: std::serialization::serializer>(s: S,
+                                                  v:
+                                                      @syntax::ast::meta_item) {
+    s.emit_box(/*syntax::ast::meta_item*/{|| serialize_6(s, *v) });
+}
+/*[@syntax::ast::meta_item]*/
+fn serialize_8<S: std::serialization::serializer>(s: S,
+                                                  v:
+                                                      [@syntax::ast::meta_item]) {
+    s.emit_vec(vec::len(v), /*@syntax::ast::meta_item*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_9(s, e) })
+                              })
+               });
+}
+/*str*/
+fn serialize_12<S: std::serialization::serializer>(s: S, v: str) {
+
+    s.emit_str(v);
+}
+/*i64*/
+fn serialize_13<S: std::serialization::serializer>(s: S, v: i64) {
+
+    s.emit_i64(v);
+}
+/*syntax::ast::int_ty*/
+fn serialize_14<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::int_ty) {
+
+    s.emit_enum("syntax::ast::int_ty",
+
+
+
+
+
+                {||
+                    alt v {
+                      syntax::ast::ty_i {
+                        s.emit_enum_variant("syntax::ast::ty_i", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_char {
+                        s.emit_enum_variant("syntax::ast::ty_char", 1u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_i8 {
+                        s.emit_enum_variant("syntax::ast::ty_i8", 2u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_i16 {
+                        s.emit_enum_variant("syntax::ast::ty_i16", 3u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_i32 {
+                        s.emit_enum_variant("syntax::ast::ty_i32", 4u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_i64 {
+                        s.emit_enum_variant("syntax::ast::ty_i64", 5u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*u64*/
+fn serialize_15<S: std::serialization::serializer>(s: S, v: u64) {
+
+    s.emit_u64(v);
+}
+/*syntax::ast::uint_ty*/
+fn serialize_16<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::uint_ty) {
+
+    s.emit_enum("syntax::ast::uint_ty",
+
+
+
+
+                {||
+                    alt v {
+                      syntax::ast::ty_u {
+                        s.emit_enum_variant("syntax::ast::ty_u", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_u8 {
+                        s.emit_enum_variant("syntax::ast::ty_u8", 1u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_u16 {
+                        s.emit_enum_variant("syntax::ast::ty_u16", 2u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_u32 {
+                        s.emit_enum_variant("syntax::ast::ty_u32", 3u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_u64 {
+                        s.emit_enum_variant("syntax::ast::ty_u64", 4u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::float_ty*/
+fn serialize_17<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::float_ty) {
+
+    s.emit_enum("syntax::ast::float_ty",
+
+
+                {||
+                    alt v {
+                      syntax::ast::ty_f {
+                        s.emit_enum_variant("syntax::ast::ty_f", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_f32 {
+                        s.emit_enum_variant("syntax::ast::ty_f32", 1u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_f64 {
+                        s.emit_enum_variant("syntax::ast::ty_f64", 2u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*bool*/
+fn serialize_18<S: std::serialization::serializer>(s: S, v: bool) {
+
+    s.emit_bool(v);
+}
+/*syntax::ast::lit_*/
+fn serialize_11<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::lit_) {
+
+    s.emit_enum("syntax::ast::lit_",
+                /*str*/
+                /*i64*//*syntax::ast::int_ty*/
+                /*u64*//*syntax::ast::uint_ty*/
+                /*str*//*syntax::ast::float_ty*/
+
+                /*bool*/
+                {||
+                    alt v {
+                      syntax::ast::lit_str(v0) {
+                        s.emit_enum_variant("syntax::ast::lit_str", 0u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_12(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::lit_int(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::lit_int", 1u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_13(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_14(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::lit_uint(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::lit_uint", 2u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_15(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_16(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::lit_float(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::lit_float", 3u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_12(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_17(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::lit_nil {
+                        s.emit_enum_variant("syntax::ast::lit_nil", 4u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::lit_bool(v0) {
+                        s.emit_enum_variant("syntax::ast::lit_bool", 5u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_18(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*uint*/
+fn serialize_20<S: std::serialization::serializer>(s: S, v: uint) {
+
+    s.emit_uint(v);
+}
+/*core::option::t<syntax::codemap::span>*/
+fn serialize_26<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       core::option::t<syntax::codemap::span>) {
+    s.emit_enum("core::option::t",
+
+                /*syntax::codemap::span*/
+                {||
+                    alt v {
+                      core::option::none {
+                        s.emit_enum_variant("core::option::none", 0u, 0u,
+                                            {|| })
+                      }
+                      core::option::some(v0) {
+                        s.emit_enum_variant("core::option::some", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_19(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*{name: str,span: core::option::t<syntax::codemap::span>}*/
+fn serialize_25<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       {name: str,
+                                                        span:
+                                                            core::option::t<syntax::codemap::span>,}) {
+    s.emit_rec(/*str*//*core::option::t<syntax::codemap::span>*/
+               {||
+                   {
+                       s.emit_rec_field("name", 0u,
+                                        {|| serialize_12(s, v.name) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_26(s, v.span) })
+                   }
+               });
+}
+
+/*{call_site: syntax::codemap::span,callie: {name: str,span: core::option::t<syntax::codemap::span>}}*/
+fn serialize_24<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       {call_site:
+                                                            syntax::codemap::span,
+                                                        callie:
+                                                            {name: str,
+                                                             span:
+                                                                 core::option::t<syntax::codemap::span>,},}) {
+    s.emit_rec(/*syntax::codemap::span*/
+               /*{name: str,span: core::option::t<syntax::codemap::span>}*/
+               {||
+                   {
+                       s.emit_rec_field("call_site", 0u,
+                                        {|| serialize_19(s, v.call_site) });
+                       s.emit_rec_field("callie", 1u,
+                                        {|| serialize_25(s, v.callie) })
+                   }
+               });
+}
+/*syntax::codemap::expn_info_*/
+fn serialize_23<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::codemap::expn_info_) {
+    s.emit_enum("syntax::codemap::expn_info_",
+
+                /*{call_site: syntax::codemap::span,callie: {name: str,span: core::option::t<syntax::codemap::span>}}*/
+                {||
+                    alt v {
+                      syntax::codemap::expanded_from(v0) {
+                        s.emit_enum_variant("syntax::codemap::expanded_from",
+                                            0u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_24(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*@syntax::codemap::expn_info_*/
+fn serialize_22<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       @syntax::codemap::expn_info_) {
+    s.emit_box(/*syntax::codemap::expn_info_*/{|| serialize_23(s, *v) });
+}
+/*syntax::codemap::expn_info<@syntax::codemap::expn_info_>*/
+fn serialize_21<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::codemap::expn_info<@syntax::codemap::expn_info_>) {
+    s.emit_enum("core::option::t",
+
+                /*@syntax::codemap::expn_info_*/
+                {||
+                    alt v {
+                      core::option::none {
+                        s.emit_enum_variant("core::option::none", 0u, 0u,
+                                            {|| })
+                      }
+                      core::option::some(v0) {
+                        s.emit_enum_variant("core::option::some", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_22(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::codemap::span*/
+fn serialize_19<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::codemap::span) {
+
+    s.emit_rec(/*uint*//*uint*/
+               /*syntax::codemap::expn_info<@syntax::codemap::expn_info_>*/
+               {||
+                   {
+                       s.emit_rec_field("lo", 0u,
+                                        {|| serialize_20(s, v.lo) });
+                       s.emit_rec_field("hi", 1u,
+                                        {|| serialize_20(s, v.hi) });
+                       s.emit_rec_field("expn_info", 2u,
+                                        {|| serialize_21(s, v.expn_info) })
+                   }
+               });
+}
+/*syntax::ast::lit*/
+fn serialize_10<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::lit) {
+
+    s.emit_rec(/*syntax::ast::lit_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_11(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*syntax::ast::meta_item_*/
+fn serialize_7<S: std::serialization::serializer>(s: S,
+                                                  v:
+                                                      syntax::ast::meta_item_) {
+    s.emit_enum("syntax::ast::meta_item_",
+                /*syntax::ast::ident*/
+                /*syntax::ast::ident*//*[@syntax::ast::meta_item]*/
+                /*syntax::ast::ident*//*syntax::ast::lit*/
+                {||
+                    alt v {
+                      syntax::ast::meta_word(v0) {
+                        s.emit_enum_variant("syntax::ast::meta_word", 0u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_1(s,
+                                                                                            v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::meta_list(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::meta_list", 1u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_1(s,
+                                                                                            v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_8(s,
+                                                                                            v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::meta_name_value(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::meta_name_value",
+                                            2u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_1(s,
+                                                                                            v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_10(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::meta_item*/
+fn serialize_6<S: std::serialization::serializer>(s: S,
+                                                  v: syntax::ast::meta_item) {
+
+    s.emit_rec(/*syntax::ast::meta_item_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_7(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*syntax::ast::attribute_*/
+fn serialize_4<S: std::serialization::serializer>(s: S,
+                                                  v:
+                                                      syntax::ast::attribute_) {
+    s.emit_rec(/*syntax::ast::attr_style*//*syntax::ast::meta_item*/
+               {||
+                   {
+                       s.emit_rec_field("style", 0u,
+                                        {|| serialize_5(s, v.style) });
+                       s.emit_rec_field("value", 1u,
+                                        {|| serialize_6(s, v.value) })
+                   }
+               });
+}
+/*syntax::ast::attribute*/
+fn serialize_3<S: std::serialization::serializer>(s: S,
+                                                  v: syntax::ast::attribute) {
+
+    s.emit_rec(/*syntax::ast::attribute_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_4(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*[syntax::ast::attribute]*/
+fn serialize_2<S: std::serialization::serializer>(s: S,
+                                                  v:
+                                                      [syntax::ast::attribute]) {
+    s.emit_vec(vec::len(v), /*syntax::ast::attribute*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_3(s, e) })
+                              })
+               });
+}
+/*syntax::ast::node_id*/
+fn serialize_27<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::node_id) {
+
+    s.emit_int(v);
+}
+/*syntax::ast::mutability*/
+fn serialize_33<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::mutability) {
+    s.emit_enum("syntax::ast::mutability",
+
+
+                {||
+                    alt v {
+                      syntax::ast::m_mutbl {
+                        s.emit_enum_variant("syntax::ast::m_mutbl", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::m_imm {
+                        s.emit_enum_variant("syntax::ast::m_imm", 1u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::m_const {
+                        s.emit_enum_variant("syntax::ast::m_const", 2u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::mt*/
+fn serialize_32<S: std::serialization::serializer>(s: S, v: syntax::ast::mt) {
+
+    s.emit_rec(/*@syntax::ast::ty*//*syntax::ast::mutability*/
+               {||
+                   {
+                       s.emit_rec_field("ty", 0u,
+                                        {|| serialize_29(s, v.ty) });
+                       s.emit_rec_field("mutbl", 1u,
+                                        {|| serialize_33(s, v.mutbl) })
+                   }
+               });
+}
+/*syntax::ast::ty_field_*/
+fn serialize_36<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::ty_field_) {
+    s.emit_rec(/*syntax::ast::ident*//*syntax::ast::mt*/
+               {||
+                   {
+                       s.emit_rec_field("ident", 0u,
+                                        {|| serialize_1(s, v.ident) });
+                       s.emit_rec_field("mt", 1u, {|| serialize_32(s, v.mt) })
+                   }
+               });
+}
+/*syntax::ast::ty_field*/
+fn serialize_35<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::ty_field) {
+
+    s.emit_rec(/*syntax::ast::ty_field_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_36(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*[syntax::ast::ty_field]*/
+fn serialize_34<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       [syntax::ast::ty_field]) {
+    s.emit_vec(vec::len(v), /*syntax::ast::ty_field*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_35(s, e) })
+                              })
+               });
+}
+/*syntax::ast::proto*/
+fn serialize_37<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::proto) {
+
+    s.emit_enum("syntax::ast::proto",
+
+
+
+
+                {||
+                    alt v {
+                      syntax::ast::proto_bare {
+                        s.emit_enum_variant("syntax::ast::proto_bare", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::proto_any {
+                        s.emit_enum_variant("syntax::ast::proto_any", 1u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::proto_uniq {
+                        s.emit_enum_variant("syntax::ast::proto_uniq", 2u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::proto_box {
+                        s.emit_enum_variant("syntax::ast::proto_box", 3u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::proto_block {
+                        s.emit_enum_variant("syntax::ast::proto_block", 4u,
+                                            0u, {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::rmode*/
+fn serialize_42<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::rmode) {
+
+    s.emit_enum("syntax::ast::rmode",
+
+
+
+
+                {||
+                    alt v {
+                      syntax::ast::by_ref {
+                        s.emit_enum_variant("syntax::ast::by_ref", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::by_val {
+                        s.emit_enum_variant("syntax::ast::by_val", 1u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::by_mutbl_ref {
+                        s.emit_enum_variant("syntax::ast::by_mutbl_ref", 2u,
+                                            0u, {|| })
+                      }
+                      syntax::ast::by_move {
+                        s.emit_enum_variant("syntax::ast::by_move", 3u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::by_copy {
+                        s.emit_enum_variant("syntax::ast::by_copy", 4u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::mode<syntax::ast::rmode>*/
+fn serialize_41<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::mode<syntax::ast::rmode>) {
+    s.emit_enum("syntax::ast::inferable",
+                /*syntax::ast::rmode*/
+                /*syntax::ast::node_id*/
+                {||
+                    alt v {
+                      syntax::ast::expl(v0) {
+                        s.emit_enum_variant("syntax::ast::expl", 0u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_42(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::infer(v0) {
+                        s.emit_enum_variant("syntax::ast::infer", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::arg*/
+fn serialize_40<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::arg) {
+
+    s.emit_rec(/*syntax::ast::mode<syntax::ast::rmode>*//*@syntax::ast::ty*/
+               /*syntax::ast::ident*//*syntax::ast::node_id*/
+               {||
+                   {
+                       s.emit_rec_field("mode", 0u,
+                                        {|| serialize_41(s, v.mode) });
+                       s.emit_rec_field("ty", 1u,
+                                        {|| serialize_29(s, v.ty) });
+                       s.emit_rec_field("ident", 2u,
+                                        {|| serialize_1(s, v.ident) });
+                       s.emit_rec_field("id", 3u, {|| serialize_27(s, v.id) })
+                   }
+               });
+}
+/*[syntax::ast::arg]*/
+fn serialize_39<S: std::serialization::serializer>(s: S,
+                                                   v: [syntax::ast::arg]) {
+
+    s.emit_vec(vec::len(v), /*syntax::ast::arg*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_40(s, e) })
+                              })
+               });
+}
+/*syntax::ast::purity*/
+fn serialize_43<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::purity) {
+
+    s.emit_enum("syntax::ast::purity",
+
+
+
+                {||
+                    alt v {
+                      syntax::ast::pure_fn {
+                        s.emit_enum_variant("syntax::ast::pure_fn", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::unsafe_fn {
+                        s.emit_enum_variant("syntax::ast::unsafe_fn", 1u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::impure_fn {
+                        s.emit_enum_variant("syntax::ast::impure_fn", 2u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::crust_fn {
+                        s.emit_enum_variant("syntax::ast::crust_fn", 3u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::ret_style*/
+fn serialize_44<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::ret_style) {
+    s.emit_enum("syntax::ast::ret_style",
+
+                {||
+                    alt v {
+                      syntax::ast::noreturn {
+                        s.emit_enum_variant("syntax::ast::noreturn", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::return_val {
+                        s.emit_enum_variant("syntax::ast::return_val", 1u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*[syntax::ast::ident]*/
+fn serialize_52<S: std::serialization::serializer>(s: S,
+                                                   v: [syntax::ast::ident]) {
+
+    s.emit_vec(vec::len(v), /*syntax::ast::ident*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_1(s, e) })
+                              })
+               });
+}
+/*[@syntax::ast::ty]*/
+fn serialize_53<S: std::serialization::serializer>(s: S,
+                                                   v: [@syntax::ast::ty]) {
+
+    s.emit_vec(vec::len(v), /*@syntax::ast::ty*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_29(s, e) })
+                              })
+               });
+}
+/*syntax::ast::path_*/
+fn serialize_51<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::path_) {
+
+    s.emit_rec(/*bool*//*[syntax::ast::ident]*//*[@syntax::ast::ty]*/
+               {||
+                   {
+                       s.emit_rec_field("global", 0u,
+                                        {|| serialize_18(s, v.global) });
+                       s.emit_rec_field("idents", 1u,
+                                        {|| serialize_52(s, v.idents) });
+                       s.emit_rec_field("types", 2u,
+                                        {|| serialize_53(s, v.types) })
+                   }
+               });
+}
+/*syntax::ast::path*/
+fn serialize_50<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::path) {
+
+    s.emit_rec(/*syntax::ast::path_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_51(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::path*/
+fn serialize_49<S: std::serialization::serializer>(s: S,
+                                                   v: @syntax::ast::path) {
+
+    s.emit_box(/*syntax::ast::path*/{|| serialize_50(s, *v) });
+}
+/*@syntax::ast::lit*/
+fn serialize_58<S: std::serialization::serializer>(s: S,
+                                                   v: @syntax::ast::lit) {
+
+    s.emit_box(/*syntax::ast::lit*/{|| serialize_10(s, *v) });
+}
+/*syntax::ast::constr_arg_general_<uint>*/
+fn serialize_57<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::constr_arg_general_<uint>) {
+    s.emit_enum("syntax::ast::constr_arg_general_",
+
+                /*uint*/
+                /*@syntax::ast::lit*/
+                {||
+                    alt v {
+                      syntax::ast::carg_base {
+                        s.emit_enum_variant("syntax::ast::carg_base", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::carg_ident(v0) {
+                        s.emit_enum_variant("syntax::ast::carg_ident", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_20(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::carg_lit(v0) {
+                        s.emit_enum_variant("syntax::ast::carg_lit", 2u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_58(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}*/
+fn serialize_56<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       {node:
+                                                            syntax::ast::constr_arg_general_<uint>,
+                                                        span:
+                                                            syntax::codemap::span,}) {
+    s.emit_rec(/*syntax::ast::constr_arg_general_<uint>*/
+               /*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_57(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+
+/*@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}*/
+fn serialize_55<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       @{node:
+                                                             syntax::ast::constr_arg_general_<uint>,
+                                                         span:
+                                                             syntax::codemap::span,}) {
+    s.emit_box(
+               /*{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}*/
+               {|| serialize_56(s, *v) });
+}
+
+/*[@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}]*/
+fn serialize_54<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       [@{node:
+                                                              syntax::ast::constr_arg_general_<uint>,
+                                                          span:
+                                                              syntax::codemap::span,}]) {
+    s.emit_vec(vec::len(v),
+               /*@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_55(s, e) })
+                              })
+               });
+}
+
+/*{path: @syntax::ast::path,args: [@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}],id: syntax::ast::node_id}*/
+fn serialize_48<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       {path:
+                                                            @syntax::ast::path,
+                                                        args:
+                                                            [@{node:
+                                                                   syntax::ast::constr_arg_general_<uint>,
+                                                               span:
+                                                                   syntax::codemap::span,}],
+                                                        id:
+                                                            syntax::ast::node_id,}) {
+    s.emit_rec(/*@syntax::ast::path*/
+               /*[@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}]*/
+               /*syntax::ast::node_id*/
+               {||
+                   {
+                       s.emit_rec_field("path", 0u,
+                                        {|| serialize_49(s, v.path) });
+                       s.emit_rec_field("args", 1u,
+                                        {|| serialize_54(s, v.args) });
+                       s.emit_rec_field("id", 2u, {|| serialize_27(s, v.id) })
+                   }
+               });
+}
+/*syntax::ast::constr*/
+fn serialize_47<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::constr) {
+
+    s.emit_rec(
+               /*{path: @syntax::ast::path,args: [@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}],id: syntax::ast::node_id}*/
+               /*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_48(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::constr*/
+fn serialize_46<S: std::serialization::serializer>(s: S,
+                                                   v: @syntax::ast::constr) {
+
+    s.emit_box(/*syntax::ast::constr*/{|| serialize_47(s, *v) });
+}
+/*[@syntax::ast::constr]*/
+fn serialize_45<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       [@syntax::ast::constr]) {
+    s.emit_vec(vec::len(v), /*@syntax::ast::constr*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_46(s, e) })
+                              })
+               });
+}
+/*syntax::ast::fn_decl*/
+fn serialize_38<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::fn_decl) {
+
+    s.emit_rec(/*[syntax::ast::arg]*//*@syntax::ast::ty*/
+               /*syntax::ast::purity*//*syntax::ast::ret_style*/
+               /*[@syntax::ast::constr]*/
+               {||
+                   {
+                       s.emit_rec_field("inputs", 0u,
+                                        {|| serialize_39(s, v.inputs) });
+                       s.emit_rec_field("output", 1u,
+                                        {|| serialize_29(s, v.output) });
+                       s.emit_rec_field("purity", 2u,
+                                        {|| serialize_43(s, v.purity) });
+                       s.emit_rec_field("cf", 3u,
+                                        {|| serialize_44(s, v.cf) });
+                       s.emit_rec_field("constraints", 4u,
+                                        {|| serialize_45(s, v.constraints) })
+                   }
+               });
+}
+/*syntax::ast::constr_arg_general_<@syntax::ast::path>*/
+fn serialize_66<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::constr_arg_general_<@syntax::ast::path>) {
+    s.emit_enum("syntax::ast::constr_arg_general_",
+
+                /*@syntax::ast::path*/
+                /*@syntax::ast::lit*/
+                {||
+                    alt v {
+                      syntax::ast::carg_base {
+                        s.emit_enum_variant("syntax::ast::carg_base", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::carg_ident(v0) {
+                        s.emit_enum_variant("syntax::ast::carg_ident", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_49(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::carg_lit(v0) {
+                        s.emit_enum_variant("syntax::ast::carg_lit", 2u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_58(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+
+/*{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/
+fn serialize_65<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       {node:
+                                                            syntax::ast::constr_arg_general_<@syntax::ast::path>,
+                                                        span:
+                                                            syntax::codemap::span,}) {
+    s.emit_rec(/*syntax::ast::constr_arg_general_<@syntax::ast::path>*/
+               /*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_66(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+
+/*@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/
+fn serialize_64<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       @{node:
+                                                             syntax::ast::constr_arg_general_<@syntax::ast::path>,
+                                                         span:
+                                                             syntax::codemap::span,}) {
+    s.emit_box(
+               /*{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/
+               {|| serialize_65(s, *v) });
+}
+
+/*[@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}]*/
+fn serialize_63<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       [@{node:
+                                                              syntax::ast::constr_arg_general_<@syntax::ast::path>,
+                                                          span:
+                                                              syntax::codemap::span,}]) {
+    s.emit_vec(vec::len(v),
+               /*@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_64(s, e) })
+                              })
+               });
+}
+/*syntax::ast::ty_constr_*/
+fn serialize_62<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::ty_constr_) {
+    s.emit_rec(/*@syntax::ast::path*/
+               /*[@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}]*/
+               /*syntax::ast::node_id*/
+               {||
+                   {
+                       s.emit_rec_field("path", 0u,
+                                        {|| serialize_49(s, v.path) });
+                       s.emit_rec_field("args", 1u,
+                                        {|| serialize_63(s, v.args) });
+                       s.emit_rec_field("id", 2u, {|| serialize_27(s, v.id) })
+                   }
+               });
+}
+/*syntax::ast::ty_constr*/
+fn serialize_61<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::ty_constr) {
+    s.emit_rec(/*syntax::ast::ty_constr_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_62(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::ty_constr*/
+fn serialize_60<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       @syntax::ast::ty_constr) {
+    s.emit_box(/*syntax::ast::ty_constr*/{|| serialize_61(s, *v) });
+}
+/*[@syntax::ast::ty_constr]*/
+fn serialize_59<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       [@syntax::ast::ty_constr]) {
+    s.emit_vec(vec::len(v), /*@syntax::ast::ty_constr*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_60(s, e) })
+                              })
+               });
+}
+/*[@syntax::ast::expr]*/
+fn serialize_73<S: std::serialization::serializer>(s: S,
+                                                   v: [@syntax::ast::expr]) {
+
+    s.emit_vec(vec::len(v), /*@syntax::ast::expr*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_70(s, e) })
+                              })
+               });
+}
+/*syntax::ast::field_*/
+fn serialize_76<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::field_) {
+
+    s.emit_rec(/*syntax::ast::mutability*//*syntax::ast::ident*/
+               /*@syntax::ast::expr*/
+               {||
+                   {
+                       s.emit_rec_field("mutbl", 0u,
+                                        {|| serialize_33(s, v.mutbl) });
+                       s.emit_rec_field("ident", 1u,
+                                        {|| serialize_1(s, v.ident) });
+                       s.emit_rec_field("expr", 2u,
+                                        {|| serialize_70(s, v.expr) })
+                   }
+               });
+}
+/*syntax::ast::field*/
+fn serialize_75<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::field) {
+
+    s.emit_rec(/*syntax::ast::field_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_76(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*[syntax::ast::field]*/
+fn serialize_74<S: std::serialization::serializer>(s: S,
+                                                   v: [syntax::ast::field]) {
+
+    s.emit_vec(vec::len(v), /*syntax::ast::field*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_75(s, e) })
+                              })
+               });
+}
+/*core::option::t<@syntax::ast::expr>*/
+fn serialize_77<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       core::option::t<@syntax::ast::expr>) {
+    s.emit_enum("core::option::t",
+
+                /*@syntax::ast::expr*/
+                {||
+                    alt v {
+                      core::option::none {
+                        s.emit_enum_variant("core::option::none", 0u, 0u,
+                                            {|| })
+                      }
+                      core::option::some(v0) {
+                        s.emit_enum_variant("core::option::some", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*[core::option::t<@syntax::ast::expr>]*/
+fn serialize_78<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       [core::option::t<@syntax::ast::expr>]) {
+    s.emit_vec(vec::len(v), /*core::option::t<@syntax::ast::expr>*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_77(s, e) })
+                              })
+               });
+}
+/*syntax::ast::binop*/
+fn serialize_79<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::binop) {
+
+    s.emit_enum("syntax::ast::binop",
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+                {||
+                    alt v {
+                      syntax::ast::add {
+                        s.emit_enum_variant("syntax::ast::add", 0u, 0u, {|| })
+                      }
+                      syntax::ast::subtract {
+                        s.emit_enum_variant("syntax::ast::subtract", 1u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::mul {
+                        s.emit_enum_variant("syntax::ast::mul", 2u, 0u, {|| })
+                      }
+                      syntax::ast::div {
+                        s.emit_enum_variant("syntax::ast::div", 3u, 0u, {|| })
+                      }
+                      syntax::ast::rem {
+                        s.emit_enum_variant("syntax::ast::rem", 4u, 0u, {|| })
+                      }
+                      syntax::ast::and {
+                        s.emit_enum_variant("syntax::ast::and", 5u, 0u, {|| })
+                      }
+                      syntax::ast::or {
+                        s.emit_enum_variant("syntax::ast::or", 6u, 0u, {|| })
+                      }
+                      syntax::ast::bitxor {
+                        s.emit_enum_variant("syntax::ast::bitxor", 7u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::bitand {
+                        s.emit_enum_variant("syntax::ast::bitand", 8u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::bitor {
+                        s.emit_enum_variant("syntax::ast::bitor", 9u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::lsl {
+                        s.emit_enum_variant("syntax::ast::lsl", 10u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::lsr {
+                        s.emit_enum_variant("syntax::ast::lsr", 11u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::asr {
+                        s.emit_enum_variant("syntax::ast::asr", 12u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::eq {
+                        s.emit_enum_variant("syntax::ast::eq", 13u, 0u, {|| })
+                      }
+                      syntax::ast::lt {
+                        s.emit_enum_variant("syntax::ast::lt", 14u, 0u, {|| })
+                      }
+                      syntax::ast::le {
+                        s.emit_enum_variant("syntax::ast::le", 15u, 0u, {|| })
+                      }
+                      syntax::ast::ne {
+                        s.emit_enum_variant("syntax::ast::ne", 16u, 0u, {|| })
+                      }
+                      syntax::ast::ge {
+                        s.emit_enum_variant("syntax::ast::ge", 17u, 0u, {|| })
+                      }
+                      syntax::ast::gt {
+                        s.emit_enum_variant("syntax::ast::gt", 18u, 0u, {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::unop*/
+fn serialize_80<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::unop) {
+
+    s.emit_enum("syntax::ast::unop",
+                /*syntax::ast::mutability*/
+                /*syntax::ast::mutability*/
+
+
+                {||
+                    alt v {
+                      syntax::ast::box(v0) {
+                        s.emit_enum_variant("syntax::ast::box", 0u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_33(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::uniq(v0) {
+                        s.emit_enum_variant("syntax::ast::uniq", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_33(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::deref {
+                        s.emit_enum_variant("syntax::ast::deref", 2u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::not {
+                        s.emit_enum_variant("syntax::ast::not", 3u, 0u, {|| })
+                      }
+                      syntax::ast::neg {
+                        s.emit_enum_variant("syntax::ast::neg", 4u, 0u, {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::simple_path*/
+fn serialize_92<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::simple_path) {
+    s.emit_vec(vec::len(v), /*syntax::ast::ident*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_1(s, e) })
+                              })
+               });
+}
+/*@syntax::ast::simple_path*/
+fn serialize_91<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       @syntax::ast::simple_path) {
+    s.emit_box(/*syntax::ast::simple_path*/{|| serialize_92(s, *v) });
+}
+/*syntax::ast::path_list_ident_*/
+fn serialize_95<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::path_list_ident_) {
+    s.emit_rec(/*syntax::ast::ident*//*syntax::ast::node_id*/
+               {||
+                   {
+                       s.emit_rec_field("name", 0u,
+                                        {|| serialize_1(s, v.name) });
+                       s.emit_rec_field("id", 1u, {|| serialize_27(s, v.id) })
+                   }
+               });
+}
+/*syntax::ast::path_list_ident*/
+fn serialize_94<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::path_list_ident) {
+    s.emit_rec(/*syntax::ast::path_list_ident_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_95(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*[syntax::ast::path_list_ident]*/
+fn serialize_93<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       [syntax::ast::path_list_ident]) {
+    s.emit_vec(vec::len(v), /*syntax::ast::path_list_ident*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_94(s, e) })
+                              })
+               });
+}
+/*syntax::ast::view_path_*/
+fn serialize_90<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::view_path_) {
+    s.emit_enum("syntax::ast::view_path_",
+                /*syntax::ast::ident*//*@syntax::ast::simple_path*/
+                /*syntax::ast::node_id*/
+                /*@syntax::ast::simple_path*//*syntax::ast::node_id*/
+                /*@syntax::ast::simple_path*/
+                /*[syntax::ast::path_list_ident]*//*syntax::ast::node_id*/
+                {||
+                    alt v {
+                      syntax::ast::view_path_simple(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::view_path_simple",
+                                            0u, 3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_1(s,
+                                                                                            v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_91(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::view_path_glob(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::view_path_glob", 1u,
+                                            2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_91(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::view_path_list(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::view_path_list", 2u,
+                                            3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_91(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_93(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::view_path*/
+fn serialize_89<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::view_path) {
+    s.emit_rec(/*syntax::ast::view_path_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_90(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::view_path*/
+fn serialize_88<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       @syntax::ast::view_path) {
+    s.emit_box(/*syntax::ast::view_path*/{|| serialize_89(s, *v) });
+}
+/*[@syntax::ast::view_path]*/
+fn serialize_87<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       [@syntax::ast::view_path]) {
+    s.emit_vec(vec::len(v), /*@syntax::ast::view_path*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_88(s, e) })
+                              })
+               });
+}
+/*syntax::ast::view_item_*/
+fn serialize_86<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::view_item_) {
+    s.emit_enum("syntax::ast::view_item_",
+                /*syntax::ast::ident*//*[@syntax::ast::meta_item]*/
+                /*syntax::ast::node_id*/
+                /*[@syntax::ast::view_path]*/
+                /*[@syntax::ast::view_path]*/
+                {||
+                    alt v {
+                      syntax::ast::view_item_use(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::view_item_use", 0u,
+                                            3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_1(s,
+                                                                                            v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_8(s,
+                                                                                            v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::view_item_import(v0) {
+                        s.emit_enum_variant("syntax::ast::view_item_import",
+                                            1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_87(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::view_item_export(v0) {
+                        s.emit_enum_variant("syntax::ast::view_item_export",
+                                            2u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_87(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::view_item*/
+fn serialize_85<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::view_item) {
+    s.emit_rec(/*syntax::ast::view_item_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_86(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::view_item*/
+fn serialize_84<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       @syntax::ast::view_item) {
+    s.emit_box(/*syntax::ast::view_item*/{|| serialize_85(s, *v) });
+}
+/*[@syntax::ast::view_item]*/
+fn serialize_83<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       [@syntax::ast::view_item]) {
+    s.emit_vec(vec::len(v), /*@syntax::ast::view_item*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_84(s, e) })
+                              })
+               });
+}
+/*core::option::t<@syntax::ast::pat>*/
+fn serialize_110<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        core::option::t<@syntax::ast::pat>) {
+    s.emit_enum("core::option::t",
+
+                /*@syntax::ast::pat*/
+                {||
+                    alt v {
+                      core::option::none {
+                        s.emit_enum_variant("core::option::none", 0u, 0u,
+                                            {|| })
+                      }
+                      core::option::some(v0) {
+                        s.emit_enum_variant("core::option::some", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_107(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*[@syntax::ast::pat]*/
+fn serialize_111<S: std::serialization::serializer>(s: S,
+                                                    v: [@syntax::ast::pat]) {
+
+    s.emit_vec(vec::len(v), /*@syntax::ast::pat*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_107(s, e) })
+                              })
+               });
+}
+/*syntax::ast::field_pat*/
+fn serialize_113<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::field_pat) {
+    s.emit_rec(/*syntax::ast::ident*//*@syntax::ast::pat*/
+               {||
+                   {
+                       s.emit_rec_field("ident", 0u,
+                                        {|| serialize_1(s, v.ident) });
+                       s.emit_rec_field("pat", 1u,
+                                        {|| serialize_107(s, v.pat) })
+                   }
+               });
+}
+/*[syntax::ast::field_pat]*/
+fn serialize_112<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [syntax::ast::field_pat]) {
+    s.emit_vec(vec::len(v), /*syntax::ast::field_pat*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_113(s, e) })
+                              })
+               });
+}
+/*syntax::ast::pat_*/
+fn serialize_109<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::pat_) {
+
+    s.emit_enum("syntax::ast::pat_",
+
+                /*@syntax::ast::path*//*core::option::t<@syntax::ast::pat>*/
+                /*@syntax::ast::path*//*[@syntax::ast::pat]*/
+                /*[syntax::ast::field_pat]*//*bool*/
+                /*[@syntax::ast::pat]*/
+                /*@syntax::ast::pat*/
+                /*@syntax::ast::pat*/
+                /*@syntax::ast::expr*/
+                /*@syntax::ast::expr*//*@syntax::ast::expr*/
+                {||
+                    alt v {
+                      syntax::ast::pat_wild {
+                        s.emit_enum_variant("syntax::ast::pat_wild", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::pat_ident(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::pat_ident", 1u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_49(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_110(s,
+                                                                                              v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::pat_enum(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::pat_enum", 2u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_49(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_111(s,
+                                                                                              v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::pat_rec(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::pat_rec", 3u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_112(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_18(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::pat_tup(v0) {
+                        s.emit_enum_variant("syntax::ast::pat_tup", 4u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_111(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::pat_box(v0) {
+                        s.emit_enum_variant("syntax::ast::pat_box", 5u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_107(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::pat_uniq(v0) {
+                        s.emit_enum_variant("syntax::ast::pat_uniq", 6u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_107(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::pat_lit(v0) {
+                        s.emit_enum_variant("syntax::ast::pat_lit", 7u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::pat_range(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::pat_range", 8u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::pat*/
+fn serialize_108<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::pat) {
+
+    s.emit_rec(/*syntax::ast::node_id*//*syntax::ast::pat_*/
+               /*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("id", 0u,
+                                        {|| serialize_27(s, v.id) });
+                       s.emit_rec_field("node", 1u,
+                                        {|| serialize_109(s, v.node) });
+                       s.emit_rec_field("span", 2u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::pat*/
+fn serialize_107<S: std::serialization::serializer>(s: S,
+                                                    v: @syntax::ast::pat) {
+
+    s.emit_box(/*syntax::ast::pat*/{|| serialize_108(s, *v) });
+}
+/*syntax::ast::init_op*/
+fn serialize_116<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::init_op) {
+
+    s.emit_enum("syntax::ast::init_op",
+
+                {||
+                    alt v {
+                      syntax::ast::init_assign {
+                        s.emit_enum_variant("syntax::ast::init_assign", 0u,
+                                            0u, {|| })
+                      }
+                      syntax::ast::init_move {
+                        s.emit_enum_variant("syntax::ast::init_move", 1u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::initializer*/
+fn serialize_115<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::initializer) {
+    s.emit_rec(/*syntax::ast::init_op*//*@syntax::ast::expr*/
+               {||
+                   {
+                       s.emit_rec_field("op", 0u,
+                                        {|| serialize_116(s, v.op) });
+                       s.emit_rec_field("expr", 1u,
+                                        {|| serialize_70(s, v.expr) })
+                   }
+               });
+}
+/*core::option::t<syntax::ast::initializer>*/
+fn serialize_114<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        core::option::t<syntax::ast::initializer>) {
+    s.emit_enum("core::option::t",
+
+                /*syntax::ast::initializer*/
+                {||
+                    alt v {
+                      core::option::none {
+                        s.emit_enum_variant("core::option::none", 0u, 0u,
+                                            {|| })
+                      }
+                      core::option::some(v0) {
+                        s.emit_enum_variant("core::option::some", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_115(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::local_*/
+fn serialize_106<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::local_) {
+
+    s.emit_rec(/*@syntax::ast::ty*//*@syntax::ast::pat*/
+               /*core::option::t<syntax::ast::initializer>*/
+               /*syntax::ast::node_id*/
+               {||
+                   {
+                       s.emit_rec_field("ty", 0u,
+                                        {|| serialize_29(s, v.ty) });
+                       s.emit_rec_field("pat", 1u,
+                                        {|| serialize_107(s, v.pat) });
+                       s.emit_rec_field("init", 2u,
+                                        {|| serialize_114(s, v.init) });
+                       s.emit_rec_field("id", 3u, {|| serialize_27(s, v.id) })
+                   }
+               });
+}
+/*syntax::ast::local*/
+fn serialize_105<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::local) {
+
+    s.emit_rec(/*syntax::ast::local_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_106(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::local*/
+fn serialize_104<S: std::serialization::serializer>(s: S,
+                                                    v: @syntax::ast::local) {
+
+    s.emit_box(/*syntax::ast::local*/{|| serialize_105(s, *v) });
+}
+/*[@syntax::ast::local]*/
+fn serialize_103<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [@syntax::ast::local]) {
+    s.emit_vec(vec::len(v), /*@syntax::ast::local*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_104(s, e) })
+                              })
+               });
+}
+/*@syntax::ast::item*/
+fn serialize_117<S: std::serialization::serializer>(s: S,
+                                                    v: @syntax::ast::item) {
+
+    s.emit_box(/*syntax::ast::item*/{|| serialize_0(s, *v) });
+}
+/*syntax::ast::decl_*/
+fn serialize_102<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::decl_) {
+
+    s.emit_enum("syntax::ast::decl_",
+                /*[@syntax::ast::local]*/
+                /*@syntax::ast::item*/
+                {||
+                    alt v {
+                      syntax::ast::decl_local(v0) {
+                        s.emit_enum_variant("syntax::ast::decl_local", 0u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_103(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::decl_item(v0) {
+                        s.emit_enum_variant("syntax::ast::decl_item", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_117(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::decl*/
+fn serialize_101<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::decl) {
+
+    s.emit_rec(/*syntax::ast::decl_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_102(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::decl*/
+fn serialize_100<S: std::serialization::serializer>(s: S,
+                                                    v: @syntax::ast::decl) {
+
+    s.emit_box(/*syntax::ast::decl*/{|| serialize_101(s, *v) });
+}
+/*syntax::ast::stmt_*/
+fn serialize_99<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::stmt_) {
+
+    s.emit_enum("syntax::ast::stmt_",
+                /*@syntax::ast::decl*//*syntax::ast::node_id*/
+                /*@syntax::ast::expr*//*syntax::ast::node_id*/
+                /*@syntax::ast::expr*//*syntax::ast::node_id*/
+                {||
+                    alt v {
+                      syntax::ast::stmt_decl(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::stmt_decl", 0u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_100(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::stmt_expr(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::stmt_expr", 1u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::stmt_semi(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::stmt_semi", 2u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::stmt*/
+fn serialize_98<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::stmt) {
+
+    s.emit_rec(/*syntax::ast::stmt_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_99(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::stmt*/
+fn serialize_97<S: std::serialization::serializer>(s: S,
+                                                   v: @syntax::ast::stmt) {
+
+    s.emit_box(/*syntax::ast::stmt*/{|| serialize_98(s, *v) });
+}
+/*[@syntax::ast::stmt]*/
+fn serialize_96<S: std::serialization::serializer>(s: S,
+                                                   v: [@syntax::ast::stmt]) {
+
+    s.emit_vec(vec::len(v), /*@syntax::ast::stmt*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_97(s, e) })
+                              })
+               });
+}
+/*syntax::ast::blk_check_mode*/
+fn serialize_118<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::blk_check_mode) {
+    s.emit_enum("syntax::ast::blk_check_mode",
+
+
+                {||
+                    alt v {
+                      syntax::ast::default_blk {
+                        s.emit_enum_variant("syntax::ast::default_blk", 0u,
+                                            0u, {|| })
+                      }
+                      syntax::ast::unchecked_blk {
+                        s.emit_enum_variant("syntax::ast::unchecked_blk", 1u,
+                                            0u, {|| })
+                      }
+                      syntax::ast::unsafe_blk {
+                        s.emit_enum_variant("syntax::ast::unsafe_blk", 2u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::blk_*/
+fn serialize_82<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::blk_) {
+
+    s.emit_rec(/*[@syntax::ast::view_item]*//*[@syntax::ast::stmt]*/
+               /*core::option::t<@syntax::ast::expr>*//*syntax::ast::node_id*/
+               /*syntax::ast::blk_check_mode*/
+               {||
+                   {
+                       s.emit_rec_field("view_items", 0u,
+                                        {|| serialize_83(s, v.view_items) });
+                       s.emit_rec_field("stmts", 1u,
+                                        {|| serialize_96(s, v.stmts) });
+                       s.emit_rec_field("expr", 2u,
+                                        {|| serialize_77(s, v.expr) });
+                       s.emit_rec_field("id", 3u,
+                                        {|| serialize_27(s, v.id) });
+                       s.emit_rec_field("rules", 4u,
+                                        {|| serialize_118(s, v.rules) })
+                   }
+               });
+}
+/*syntax::ast::blk*/
+fn serialize_81<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::blk) {
+
+    s.emit_rec(/*syntax::ast::blk_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_82(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*syntax::ast::arm*/
+fn serialize_120<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::arm) {
+
+    s.emit_rec(/*[@syntax::ast::pat]*//*core::option::t<@syntax::ast::expr>*/
+               /*syntax::ast::blk*/
+               {||
+                   {
+                       s.emit_rec_field("pats", 0u,
+                                        {|| serialize_111(s, v.pats) });
+                       s.emit_rec_field("guard", 1u,
+                                        {|| serialize_77(s, v.guard) });
+                       s.emit_rec_field("body", 2u,
+                                        {|| serialize_81(s, v.body) })
+                   }
+               });
+}
+/*[syntax::ast::arm]*/
+fn serialize_119<S: std::serialization::serializer>(s: S,
+                                                    v: [syntax::ast::arm]) {
+
+    s.emit_vec(vec::len(v), /*syntax::ast::arm*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_120(s, e) })
+                              })
+               });
+}
+/*syntax::ast::alt_mode*/
+fn serialize_121<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::alt_mode) {
+    s.emit_enum("syntax::ast::alt_mode",
+
+                {||
+                    alt v {
+                      syntax::ast::alt_check {
+                        s.emit_enum_variant("syntax::ast::alt_check", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::alt_exhaustive {
+                        s.emit_enum_variant("syntax::ast::alt_exhaustive", 1u,
+                                            0u, {|| })
+                      }
+                    }
+                });
+}
+/*int*/
+fn serialize_127<S: std::serialization::serializer>(s: S, v: int) {
+
+    s.emit_int(v);
+}
+/*syntax::ast::capture_item*/
+fn serialize_126<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::capture_item) {
+    s.emit_rec(/*int*//*syntax::ast::ident*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("id", 0u,
+                                        {|| serialize_127(s, v.id) });
+                       s.emit_rec_field("name", 1u,
+                                        {|| serialize_1(s, v.name) });
+                       s.emit_rec_field("span", 2u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::capture_item*/
+fn serialize_125<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        @syntax::ast::capture_item) {
+    s.emit_box(/*syntax::ast::capture_item*/{|| serialize_126(s, *v) });
+}
+/*[@syntax::ast::capture_item]*/
+fn serialize_124<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [@syntax::ast::capture_item]) {
+    s.emit_vec(vec::len(v), /*@syntax::ast::capture_item*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_125(s, e) })
+                              })
+               });
+}
+/*syntax::ast::capture_clause*/
+fn serialize_123<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::capture_clause) {
+    s.emit_rec(/*[@syntax::ast::capture_item]*/
+               /*[@syntax::ast::capture_item]*/
+               {||
+                   {
+                       s.emit_rec_field("copies", 0u,
+                                        {|| serialize_124(s, v.copies) });
+                       s.emit_rec_field("moves", 1u,
+                                        {|| serialize_124(s, v.moves) })
+                   }
+               });
+}
+/*@syntax::ast::capture_clause*/
+fn serialize_122<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        @syntax::ast::capture_clause) {
+    s.emit_box(/*syntax::ast::capture_clause*/{|| serialize_123(s, *v) });
+}
+/*syntax::ast::expr_check_mode*/
+fn serialize_128<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::expr_check_mode) {
+    s.emit_enum("syntax::ast::expr_check_mode",
+
+                {||
+                    alt v {
+                      syntax::ast::claimed_expr {
+                        s.emit_enum_variant("syntax::ast::claimed_expr", 0u,
+                                            0u, {|| })
+                      }
+                      syntax::ast::checked_expr {
+                        s.emit_enum_variant("syntax::ast::checked_expr", 1u,
+                                            0u, {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::expr_*/
+fn serialize_72<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::expr_) {
+
+    s.emit_enum("syntax::ast::expr_",
+                /*[@syntax::ast::expr]*//*syntax::ast::mutability*/
+                /*[syntax::ast::field]*/
+                /*core::option::t<@syntax::ast::expr>*/
+                /*@syntax::ast::expr*//*[@syntax::ast::expr]*//*bool*/
+                /*[@syntax::ast::expr]*/
+                /*@syntax::ast::expr*/
+                /*[core::option::t<@syntax::ast::expr>]*/
+                /*syntax::ast::binop*//*@syntax::ast::expr*/
+                /*@syntax::ast::expr*/
+                /*syntax::ast::unop*//*@syntax::ast::expr*/
+                /*@syntax::ast::lit*/
+                /*@syntax::ast::expr*//*@syntax::ast::ty*/
+                /*@syntax::ast::expr*//*syntax::ast::blk*/
+                /*core::option::t<@syntax::ast::expr>*/
+                /*@syntax::ast::expr*//*syntax::ast::blk*/
+                /*@syntax::ast::local*//*@syntax::ast::expr*/
+                /*syntax::ast::blk*/
+                /*syntax::ast::blk*//*@syntax::ast::expr*/
+                /*@syntax::ast::expr*//*[syntax::ast::arm]*/
+                /*syntax::ast::alt_mode*/
+                /*syntax::ast::proto*//*syntax::ast::fn_decl*/
+                /*syntax::ast::blk*//*@syntax::ast::capture_clause*/
+                /*syntax::ast::fn_decl*//*syntax::ast::blk*/
+                /*syntax::ast::blk*/
+                /*@syntax::ast::expr*/
+                /*@syntax::ast::expr*//*@syntax::ast::expr*/
+                /*@syntax::ast::expr*//*@syntax::ast::expr*/
+                /*@syntax::ast::expr*//*@syntax::ast::expr*/
+                /*syntax::ast::binop*//*@syntax::ast::expr*/
+                /*@syntax::ast::expr*/
+                /*@syntax::ast::expr*//*syntax::ast::ident*/
+                /*[@syntax::ast::ty]*/
+                /*@syntax::ast::expr*//*@syntax::ast::expr*/
+                /*@syntax::ast::path*/
+                /*core::option::t<@syntax::ast::expr>*/
+
+
+                /*core::option::t<@syntax::ast::expr>*/
+                /*@syntax::ast::expr*/
+                /*int*//*@syntax::ast::expr*//*@syntax::ast::expr*/
+                /*@syntax::ast::expr*/
+                /*syntax::ast::expr_check_mode*//*@syntax::ast::expr*/
+                /*@syntax::ast::expr*//*syntax::ast::blk*/
+                /*core::option::t<@syntax::ast::expr>*/
+                /*syntax::ast::mac*/
+                {||
+                    alt v {
+                      syntax::ast::expr_vec(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_vec", 0u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_73(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_33(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_rec(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_rec", 1u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_74(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_77(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_call(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::expr_call", 2u, 3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_73(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_18(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_tup(v0) {
+                        s.emit_enum_variant("syntax::ast::expr_tup", 3u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_73(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_bind(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_bind", 4u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_78(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_binary(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::expr_binary", 5u,
+                                            3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_79(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_unary(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_unary", 6u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_80(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_lit(v0) {
+                        s.emit_enum_variant("syntax::ast::expr_lit", 7u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_58(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_cast(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_cast", 8u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_29(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_if(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::expr_if", 9u, 3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_77(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_while(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_while", 10u,
+                                            2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_for(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::expr_for", 11u, 3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_104(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_do_while(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_do_while", 12u,
+                                            2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_alt(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::expr_alt", 13u, 3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_119(s,
+                                                                                              v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_121(s,
+                                                                                              v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_fn(v0, v1, v2, v3) {
+                        s.emit_enum_variant("syntax::ast::expr_fn", 14u, 4u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_37(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_38(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v2)
+                                                                            });
+                                                    s.emit_enum_variant_arg(3u,
+                                                                            {||
+                                                                                serialize_122(s,
+                                                                                              v3)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_fn_block(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_fn_block", 15u,
+                                            2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_38(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_block(v0) {
+                        s.emit_enum_variant("syntax::ast::expr_block", 16u,
+                                            1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_copy(v0) {
+                        s.emit_enum_variant("syntax::ast::expr_copy", 17u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_move(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_move", 18u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_assign(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_assign", 19u,
+                                            2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_swap(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_swap", 20u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_assign_op(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::expr_assign_op",
+                                            21u, 3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_79(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_field(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::expr_field", 22u,
+                                            3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_1(s,
+                                                                                            v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_53(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_index(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_index", 23u,
+                                            2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_path(v0) {
+                        s.emit_enum_variant("syntax::ast::expr_path", 24u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_49(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_fail(v0) {
+                        s.emit_enum_variant("syntax::ast::expr_fail", 25u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_77(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_break {
+                        s.emit_enum_variant("syntax::ast::expr_break", 26u,
+                                            0u, {|| })
+                      }
+                      syntax::ast::expr_cont {
+                        s.emit_enum_variant("syntax::ast::expr_cont", 27u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::expr_ret(v0) {
+                        s.emit_enum_variant("syntax::ast::expr_ret", 28u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_77(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_be(v0) {
+                        s.emit_enum_variant("syntax::ast::expr_be", 29u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_log(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::expr_log", 30u, 3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_127(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_assert(v0) {
+                        s.emit_enum_variant("syntax::ast::expr_assert", 31u,
+                                            1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_check(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::expr_check", 32u,
+                                            2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_128(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_if_check(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::expr_if_check", 33u,
+                                            3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_77(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::expr_mac(v0) {
+                        s.emit_enum_variant("syntax::ast::expr_mac", 34u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_67(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::expr*/
+fn serialize_71<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::expr) {
+
+    s.emit_rec(/*syntax::ast::node_id*//*syntax::ast::expr_*/
+               /*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("id", 0u,
+                                        {|| serialize_27(s, v.id) });
+                       s.emit_rec_field("node", 1u,
+                                        {|| serialize_72(s, v.node) });
+                       s.emit_rec_field("span", 2u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::expr*/
+fn serialize_70<S: std::serialization::serializer>(s: S,
+                                                   v: @syntax::ast::expr) {
+
+    s.emit_box(/*syntax::ast::expr*/{|| serialize_71(s, *v) });
+}
+/*syntax::ast::mac_arg<@syntax::ast::expr>*/
+fn serialize_69<S: std::serialization::serializer>(s: S,
+                                                   v:
+                                                       syntax::ast::mac_arg<@syntax::ast::expr>) {
+    s.emit_enum("core::option::t",
+
+                /*@syntax::ast::expr*/
+                {||
+                    alt v {
+                      core::option::none {
+                        s.emit_enum_variant("core::option::none", 0u, 0u,
+                                            {|| })
+                      }
+                      core::option::some(v0) {
+                        s.emit_enum_variant("core::option::some", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::mac_body_*/
+fn serialize_130<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::mac_body_) {
+    s.emit_rec(/*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("span", 0u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*syntax::ast::mac_body<syntax::ast::mac_body_>*/
+fn serialize_129<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::mac_body<syntax::ast::mac_body_>) {
+    s.emit_enum("core::option::t",
+
+                /*syntax::ast::mac_body_*/
+                {||
+                    alt v {
+                      core::option::none {
+                        s.emit_enum_variant("core::option::none", 0u, 0u,
+                                            {|| })
+                      }
+                      core::option::some(v0) {
+                        s.emit_enum_variant("core::option::some", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_130(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::mac_*/
+fn serialize_68<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::mac_) {
+
+    s.emit_enum("syntax::ast::mac_",
+                /*@syntax::ast::path*/
+                /*syntax::ast::mac_arg<@syntax::ast::expr>*/
+                /*syntax::ast::mac_body<syntax::ast::mac_body_>*/
+                /*@syntax::ast::ty*/
+                /*syntax::ast::blk*/
+
+                /*syntax::codemap::span*//*@syntax::ast::expr*/
+                /*uint*/
+                {||
+                    alt v {
+                      syntax::ast::mac_invoc(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::mac_invoc", 0u, 3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_49(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_69(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_129(s,
+                                                                                              v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::mac_embed_type(v0) {
+                        s.emit_enum_variant("syntax::ast::mac_embed_type", 1u,
+                                            1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_29(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::mac_embed_block(v0) {
+                        s.emit_enum_variant("syntax::ast::mac_embed_block",
+                                            2u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::mac_ellipsis {
+                        s.emit_enum_variant("syntax::ast::mac_ellipsis", 3u,
+                                            0u, {|| })
+                      }
+                      syntax::ast::mac_aq(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::mac_aq", 4u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_19(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::mac_var(v0) {
+                        s.emit_enum_variant("syntax::ast::mac_var", 5u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_20(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::mac*/
+fn serialize_67<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::mac) {
+
+    s.emit_rec(/*syntax::ast::mac_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_68(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*syntax::ast::ty_*/
+fn serialize_31<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::ty_) {
+
+    s.emit_enum("syntax::ast::ty_",
+
+
+                /*syntax::ast::mt*/
+                /*syntax::ast::mt*/
+                /*syntax::ast::mt*/
+                /*syntax::ast::mt*/
+                /*[syntax::ast::ty_field]*/
+                /*syntax::ast::proto*//*syntax::ast::fn_decl*/
+                /*[@syntax::ast::ty]*/
+                /*@syntax::ast::path*//*syntax::ast::node_id*/
+                /*@syntax::ast::ty*//*[@syntax::ast::ty_constr]*/
+                /*syntax::ast::mac*/
+                {||
+                    alt v {
+                      syntax::ast::ty_nil {
+                        s.emit_enum_variant("syntax::ast::ty_nil", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_bot {
+                        s.emit_enum_variant("syntax::ast::ty_bot", 1u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_box(v0) {
+                        s.emit_enum_variant("syntax::ast::ty_box", 2u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_32(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_uniq(v0) {
+                        s.emit_enum_variant("syntax::ast::ty_uniq", 3u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_32(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_vec(v0) {
+                        s.emit_enum_variant("syntax::ast::ty_vec", 4u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_32(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_ptr(v0) {
+                        s.emit_enum_variant("syntax::ast::ty_ptr", 5u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_32(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_rec(v0) {
+                        s.emit_enum_variant("syntax::ast::ty_rec", 6u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_34(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_fn(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::ty_fn", 7u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_37(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_38(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_tup(v0) {
+                        s.emit_enum_variant("syntax::ast::ty_tup", 8u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_53(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_path(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::ty_path", 9u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_49(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_constr(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::ty_constr", 10u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_29(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_59(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_mac(v0) {
+                        s.emit_enum_variant("syntax::ast::ty_mac", 11u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_67(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_infer {
+                        s.emit_enum_variant("syntax::ast::ty_infer", 12u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::ty*/
+fn serialize_30<S: std::serialization::serializer>(s: S, v: syntax::ast::ty) {
+
+    s.emit_rec(/*syntax::ast::ty_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_31(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::ty*/
+fn serialize_29<S: std::serialization::serializer>(s: S,
+                                                   v: @syntax::ast::ty) {
+
+    s.emit_box(/*syntax::ast::ty*/{|| serialize_30(s, *v) });
+}
+/*syntax::ast::ty_param_bound*/
+fn serialize_135<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::ty_param_bound) {
+    s.emit_enum("syntax::ast::ty_param_bound",
+
+
+                /*@syntax::ast::ty*/
+                {||
+                    alt v {
+                      syntax::ast::bound_copy {
+                        s.emit_enum_variant("syntax::ast::bound_copy", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::bound_send {
+                        s.emit_enum_variant("syntax::ast::bound_send", 1u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::bound_iface(v0) {
+                        s.emit_enum_variant("syntax::ast::bound_iface", 2u,
+                                            1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_29(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*[syntax::ast::ty_param_bound]*/
+fn serialize_134<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [syntax::ast::ty_param_bound]) {
+    s.emit_vec(vec::len(v), /*syntax::ast::ty_param_bound*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_135(s, e) })
+                              })
+               });
+}
+/*@[syntax::ast::ty_param_bound]*/
+fn serialize_133<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        @[syntax::ast::ty_param_bound]) {
+    s.emit_box(/*[syntax::ast::ty_param_bound]*/{|| serialize_134(s, *v) });
+}
+/*syntax::ast::ty_param*/
+fn serialize_132<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::ty_param) {
+    s.emit_rec(/*syntax::ast::ident*//*syntax::ast::node_id*/
+               /*@[syntax::ast::ty_param_bound]*/
+               {||
+                   {
+                       s.emit_rec_field("ident", 0u,
+                                        {|| serialize_1(s, v.ident) });
+                       s.emit_rec_field("id", 1u,
+                                        {|| serialize_27(s, v.id) });
+                       s.emit_rec_field("bounds", 2u,
+                                        {|| serialize_133(s, v.bounds) })
+                   }
+               });
+}
+/*[syntax::ast::ty_param]*/
+fn serialize_131<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [syntax::ast::ty_param]) {
+    s.emit_vec(vec::len(v), /*syntax::ast::ty_param*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_132(s, e) })
+                              })
+               });
+}
+/*[@syntax::ast::item]*/
+fn serialize_137<S: std::serialization::serializer>(s: S,
+                                                    v: [@syntax::ast::item]) {
+
+    s.emit_vec(vec::len(v), /*@syntax::ast::item*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_117(s, e) })
+                              })
+               });
+}
+/*syntax::ast::_mod*/
+fn serialize_136<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::_mod) {
+
+    s.emit_rec(/*[@syntax::ast::view_item]*//*[@syntax::ast::item]*/
+               {||
+                   {
+                       s.emit_rec_field("view_items", 0u,
+                                        {|| serialize_83(s, v.view_items) });
+                       s.emit_rec_field("items", 1u,
+                                        {|| serialize_137(s, v.items) })
+                   }
+               });
+}
+/*syntax::ast::native_item_*/
+fn serialize_142<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::native_item_) {
+    s.emit_enum("syntax::ast::native_item_",
+                /*syntax::ast::fn_decl*//*[syntax::ast::ty_param]*/
+                {||
+                    alt v {
+                      syntax::ast::native_item_fn(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::native_item_fn", 0u,
+                                            2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_38(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_131(s,
+                                                                                              v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::native_item*/
+fn serialize_141<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::native_item) {
+    s.emit_rec(/*syntax::ast::ident*//*[syntax::ast::attribute]*/
+               /*syntax::ast::native_item_*//*syntax::ast::node_id*/
+               /*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("ident", 0u,
+                                        {|| serialize_1(s, v.ident) });
+                       s.emit_rec_field("attrs", 1u,
+                                        {|| serialize_2(s, v.attrs) });
+                       s.emit_rec_field("node", 2u,
+                                        {|| serialize_142(s, v.node) });
+                       s.emit_rec_field("id", 3u,
+                                        {|| serialize_27(s, v.id) });
+                       s.emit_rec_field("span", 4u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::native_item*/
+fn serialize_140<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        @syntax::ast::native_item) {
+    s.emit_box(/*syntax::ast::native_item*/{|| serialize_141(s, *v) });
+}
+/*[@syntax::ast::native_item]*/
+fn serialize_139<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [@syntax::ast::native_item]) {
+    s.emit_vec(vec::len(v), /*@syntax::ast::native_item*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_140(s, e) })
+                              })
+               });
+}
+/*syntax::ast::native_mod*/
+fn serialize_138<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::native_mod) {
+    s.emit_rec(/*[@syntax::ast::view_item]*//*[@syntax::ast::native_item]*/
+               {||
+                   {
+                       s.emit_rec_field("view_items", 0u,
+                                        {|| serialize_83(s, v.view_items) });
+                       s.emit_rec_field("items", 1u,
+                                        {|| serialize_139(s, v.items) })
+                   }
+               });
+}
+/*syntax::ast::variant_arg*/
+fn serialize_147<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::variant_arg) {
+    s.emit_rec(/*@syntax::ast::ty*//*syntax::ast::node_id*/
+               {||
+                   {
+                       s.emit_rec_field("ty", 0u,
+                                        {|| serialize_29(s, v.ty) });
+                       s.emit_rec_field("id", 1u, {|| serialize_27(s, v.id) })
+                   }
+               });
+}
+/*[syntax::ast::variant_arg]*/
+fn serialize_146<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [syntax::ast::variant_arg]) {
+    s.emit_vec(vec::len(v), /*syntax::ast::variant_arg*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_147(s, e) })
+                              })
+               });
+}
+/*syntax::ast::variant_*/
+fn serialize_145<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::variant_) {
+    s.emit_rec(/*syntax::ast::ident*//*[syntax::ast::attribute]*/
+               /*[syntax::ast::variant_arg]*//*syntax::ast::node_id*/
+               /*core::option::t<@syntax::ast::expr>*/
+               {||
+                   {
+                       s.emit_rec_field("name", 0u,
+                                        {|| serialize_1(s, v.name) });
+                       s.emit_rec_field("attrs", 1u,
+                                        {|| serialize_2(s, v.attrs) });
+                       s.emit_rec_field("args", 2u,
+                                        {|| serialize_146(s, v.args) });
+                       s.emit_rec_field("id", 3u,
+                                        {|| serialize_27(s, v.id) });
+                       s.emit_rec_field("disr_expr", 4u,
+                                        {|| serialize_77(s, v.disr_expr) })
+                   }
+               });
+}
+/*syntax::ast::variant*/
+fn serialize_144<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::variant) {
+
+    s.emit_rec(/*syntax::ast::variant_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_145(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*[syntax::ast::variant]*/
+fn serialize_143<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [syntax::ast::variant]) {
+    s.emit_vec(vec::len(v), /*syntax::ast::variant*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_144(s, e) })
+                              })
+               });
+}
+/*syntax::ast::privacy*/
+fn serialize_152<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::privacy) {
+
+    s.emit_enum("syntax::ast::privacy",
+
+                {||
+                    alt v {
+                      syntax::ast::priv {
+                        s.emit_enum_variant("syntax::ast::priv", 0u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::pub {
+                        s.emit_enum_variant("syntax::ast::pub", 1u, 0u, {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::class_mutability*/
+fn serialize_154<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::class_mutability) {
+    s.emit_enum("syntax::ast::class_mutability",
+
+                {||
+                    alt v {
+                      syntax::ast::class_mutable {
+                        s.emit_enum_variant("syntax::ast::class_mutable", 0u,
+                                            0u, {|| })
+                      }
+                      syntax::ast::class_immutable {
+                        s.emit_enum_variant("syntax::ast::class_immutable",
+                                            1u, 0u, {|| })
+                      }
+                    }
+                });
+}
+/*syntax::ast::class_member*/
+fn serialize_153<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::class_member) {
+    s.emit_enum("syntax::ast::class_member",
+                /*syntax::ast::ident*//*@syntax::ast::ty*/
+                /*syntax::ast::class_mutability*//*syntax::ast::node_id*/
+                /*@syntax::ast::item*/
+                {||
+                    alt v {
+                      syntax::ast::instance_var(v0, v1, v2, v3) {
+                        s.emit_enum_variant("syntax::ast::instance_var", 0u,
+                                            4u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_1(s,
+                                                                                            v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_29(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_154(s,
+                                                                                              v2)
+                                                                            });
+                                                    s.emit_enum_variant_arg(3u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v3)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::class_method(v0) {
+                        s.emit_enum_variant("syntax::ast::class_method", 1u,
+                                            1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_117(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::class_item_*/
+fn serialize_151<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::class_item_) {
+    s.emit_rec(/*syntax::ast::privacy*//*syntax::ast::class_member*/
+               {||
+                   {
+                       s.emit_rec_field("privacy", 0u,
+                                        {|| serialize_152(s, v.privacy) });
+                       s.emit_rec_field("decl", 1u,
+                                        {|| serialize_153(s, v.decl) })
+                   }
+               });
+}
+/*syntax::ast::class_item*/
+fn serialize_150<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::class_item) {
+    s.emit_rec(/*syntax::ast::class_item_*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("node", 0u,
+                                        {|| serialize_151(s, v.node) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::class_item*/
+fn serialize_149<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        @syntax::ast::class_item) {
+    s.emit_box(/*syntax::ast::class_item*/{|| serialize_150(s, *v) });
+}
+/*[@syntax::ast::class_item]*/
+fn serialize_148<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [@syntax::ast::class_item]) {
+    s.emit_vec(vec::len(v), /*@syntax::ast::class_item*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_149(s, e) })
+                              })
+               });
+}
+/*syntax::ast::ty_method*/
+fn serialize_156<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::ty_method) {
+    s.emit_rec(/*syntax::ast::ident*//*[syntax::ast::attribute]*/
+               /*syntax::ast::fn_decl*//*[syntax::ast::ty_param]*/
+               /*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("ident", 0u,
+                                        {|| serialize_1(s, v.ident) });
+                       s.emit_rec_field("attrs", 1u,
+                                        {|| serialize_2(s, v.attrs) });
+                       s.emit_rec_field("decl", 2u,
+                                        {|| serialize_38(s, v.decl) });
+                       s.emit_rec_field("tps", 3u,
+                                        {|| serialize_131(s, v.tps) });
+                       s.emit_rec_field("span", 4u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*[syntax::ast::ty_method]*/
+fn serialize_155<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [syntax::ast::ty_method]) {
+    s.emit_vec(vec::len(v), /*syntax::ast::ty_method*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_156(s, e) })
+                              })
+               });
+}
+/*core::option::t<@syntax::ast::ty>*/
+fn serialize_157<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        core::option::t<@syntax::ast::ty>) {
+    s.emit_enum("core::option::t",
+
+                /*@syntax::ast::ty*/
+                {||
+                    alt v {
+                      core::option::none {
+                        s.emit_enum_variant("core::option::none", 0u, 0u,
+                                            {|| })
+                      }
+                      core::option::some(v0) {
+                        s.emit_enum_variant("core::option::some", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_29(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::method*/
+fn serialize_160<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::method) {
+
+    s.emit_rec(/*syntax::ast::ident*//*[syntax::ast::attribute]*/
+               /*[syntax::ast::ty_param]*//*syntax::ast::fn_decl*/
+               /*syntax::ast::blk*//*syntax::ast::node_id*/
+               /*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("ident", 0u,
+                                        {|| serialize_1(s, v.ident) });
+                       s.emit_rec_field("attrs", 1u,
+                                        {|| serialize_2(s, v.attrs) });
+                       s.emit_rec_field("tps", 2u,
+                                        {|| serialize_131(s, v.tps) });
+                       s.emit_rec_field("decl", 3u,
+                                        {|| serialize_38(s, v.decl) });
+                       s.emit_rec_field("body", 4u,
+                                        {|| serialize_81(s, v.body) });
+                       s.emit_rec_field("id", 5u,
+                                        {|| serialize_27(s, v.id) });
+                       s.emit_rec_field("span", 6u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+/*@syntax::ast::method*/
+fn serialize_159<S: std::serialization::serializer>(s: S,
+                                                    v: @syntax::ast::method) {
+
+    s.emit_box(/*syntax::ast::method*/{|| serialize_160(s, *v) });
+}
+/*[@syntax::ast::method]*/
+fn serialize_158<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        [@syntax::ast::method]) {
+    s.emit_vec(vec::len(v), /*@syntax::ast::method*/
+               {||
+                   vec::iteri(v,
+                              {|i, e|
+                                  s.emit_vec_elt(i, {|| serialize_159(s, e) })
+                              })
+               });
+}
+/*syntax::ast::item_*/
+fn serialize_28<S: std::serialization::serializer>(s: S,
+                                                   v: syntax::ast::item_) {
+
+    s.emit_enum("syntax::ast::item_",
+                /*@syntax::ast::ty*//*@syntax::ast::expr*/
+                /*syntax::ast::fn_decl*//*[syntax::ast::ty_param]*/
+                /*syntax::ast::blk*/
+                /*syntax::ast::_mod*/
+                /*syntax::ast::native_mod*/
+                /*@syntax::ast::ty*//*[syntax::ast::ty_param]*/
+                /*[syntax::ast::variant]*//*[syntax::ast::ty_param]*/
+                /*syntax::ast::fn_decl*//*[syntax::ast::ty_param]*/
+                /*syntax::ast::blk*//*syntax::ast::node_id*/
+                /*syntax::ast::node_id*/
+                /*[syntax::ast::ty_param]*//*[@syntax::ast::class_item]*/
+                /*syntax::ast::node_id*//*syntax::ast::fn_decl*/
+                /*syntax::ast::blk*/
+                /*[syntax::ast::ty_param]*//*[syntax::ast::ty_method]*/
+                /*[syntax::ast::ty_param]*/
+                /*core::option::t<@syntax::ast::ty>*//*@syntax::ast::ty*/
+                /*[@syntax::ast::method]*/
+                {||
+                    alt v {
+                      syntax::ast::item_const(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::item_const", 0u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_29(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_70(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::item_fn(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::item_fn", 1u, 3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_38(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_131(s,
+                                                                                              v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::item_mod(v0) {
+                        s.emit_enum_variant("syntax::ast::item_mod", 2u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_136(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::item_native_mod(v0) {
+                        s.emit_enum_variant("syntax::ast::item_native_mod",
+                                            3u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_138(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::item_ty(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::item_ty", 4u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_29(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_131(s,
+                                                                                              v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::item_enum(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::item_enum", 5u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_143(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_131(s,
+                                                                                              v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::item_res(v0, v1, v2, v3, v4) {
+                        s.emit_enum_variant("syntax::ast::item_res", 6u, 5u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_38(s,
+                                                                                             v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_131(s,
+                                                                                              v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v2)
+                                                                            });
+                                                    s.emit_enum_variant_arg(3u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v3)
+                                                                            });
+                                                    s.emit_enum_variant_arg(4u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v4)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::item_class(v0, v1, v2, v3, v4) {
+                        s.emit_enum_variant("syntax::ast::item_class", 7u, 5u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_131(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_148(s,
+                                                                                              v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v2)
+                                                                            });
+                                                    s.emit_enum_variant_arg(3u,
+                                                                            {||
+                                                                                serialize_38(s,
+                                                                                             v3)
+                                                                            });
+                                                    s.emit_enum_variant_arg(4u,
+                                                                            {||
+                                                                                serialize_81(s,
+                                                                                             v4)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::item_iface(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::item_iface", 8u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_131(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_155(s,
+                                                                                              v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::item_impl(v0, v1, v2, v3) {
+                        s.emit_enum_variant("syntax::ast::item_impl", 9u, 4u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_131(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_157(s,
+                                                                                              v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_29(s,
+                                                                                             v2)
+                                                                            });
+                                                    s.emit_enum_variant_arg(3u,
+                                                                            {||
+                                                                                serialize_158(s,
+                                                                                              v3)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+/*syntax::ast::item*/
+fn serialize_0<S: std::serialization::serializer>(s: S,
+                                                  v: syntax::ast::item) {
+
+    s.emit_rec(/*syntax::ast::ident*//*[syntax::ast::attribute]*/
+               /*syntax::ast::node_id*//*syntax::ast::item_*/
+               /*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("ident", 0u,
+                                        {|| serialize_1(s, v.ident) });
+                       s.emit_rec_field("attrs", 1u,
+                                        {|| serialize_2(s, v.attrs) });
+                       s.emit_rec_field("id", 2u,
+                                        {|| serialize_27(s, v.id) });
+                       s.emit_rec_field("node", 3u,
+                                        {|| serialize_28(s, v.node) });
+                       s.emit_rec_field("span", 4u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+fn serialize_syntax_ast_item<S: std::serialization::serializer>(s: S,
+                                                                v:
+                                                                    syntax::ast::item) {
+    serialize_0(s, v);
+}
+/*syntax::ast::ident*/
+fn deserialize_1<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ident {
+    s.read_str()
+}
+/*syntax::ast::attr_style*/
+fn deserialize_5<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::attr_style {
+    s.read_enum("syntax::ast::attr_style",
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::attr_outer }
+                                              1u { syntax::ast::attr_inner }
+                                            }
+                                        })
+                })
+}
+/*@syntax::ast::meta_item*/
+fn deserialize_9<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::meta_item {
+
+    s.read_box(/*syntax::ast::meta_item*/{|| @deserialize_6(s) })
+
+}
+/*[@syntax::ast::meta_item]*/
+fn deserialize_8<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::meta_item] {
+    s.read_vec(
+
+               /*@syntax::ast::meta_item*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_9(s) })
+                                })
+               })
+}
+/*str*/
+fn deserialize_12<S: std::serialization::deserializer>(s: S) -> str {
+    s.read_str()
+}
+/*i64*/
+fn deserialize_13<S: std::serialization::deserializer>(s: S) -> i64 {
+    s.read_i64()
+}
+/*syntax::ast::int_ty*/
+fn deserialize_14<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::int_ty {
+    s.read_enum("syntax::ast::int_ty",
+
+
+
+
+
+
+
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::ty_i }
+                                              1u { syntax::ast::ty_char }
+                                              2u { syntax::ast::ty_i8 }
+                                              3u { syntax::ast::ty_i16 }
+                                              4u { syntax::ast::ty_i32 }
+                                              5u { syntax::ast::ty_i64 }
+                                            }
+                                        })
+                })
+}
+/*u64*/
+fn deserialize_15<S: std::serialization::deserializer>(s: S) -> u64 {
+    s.read_u64()
+}
+/*syntax::ast::uint_ty*/
+fn deserialize_16<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::uint_ty {
+    s.read_enum("syntax::ast::uint_ty",
+
+
+
+
+
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::ty_u }
+                                              1u { syntax::ast::ty_u8 }
+                                              2u { syntax::ast::ty_u16 }
+                                              3u { syntax::ast::ty_u32 }
+                                              4u { syntax::ast::ty_u64 }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::float_ty*/
+fn deserialize_17<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::float_ty {
+    s.read_enum("syntax::ast::float_ty",
+
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::ty_f }
+                                              1u { syntax::ast::ty_f32 }
+                                              2u { syntax::ast::ty_f64 }
+                                            }
+                                        })
+                })
+}
+/*bool*/
+fn deserialize_18<S: std::serialization::deserializer>(s: S) -> bool {
+    s.read_bool()
+}
+/*syntax::ast::lit_*/
+fn deserialize_11<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::lit_ {
+    s.read_enum("syntax::ast::lit_",
+                /*str*/
+
+                /*i64*//*syntax::ast::int_ty*/
+
+                /*u64*//*syntax::ast::uint_ty*/
+
+                /*str*//*syntax::ast::float_ty*/
+
+
+
+                /*bool*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::lit_str(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_12(s)
+                                                                                             }))
+                                              }
+                                              1u {
+                                                syntax::ast::lit_int(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_13(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(1u,
+                                                                                             {||
+                                                                                                 deserialize_14(s)
+                                                                                             }))
+                                              }
+                                              2u {
+                                                syntax::ast::lit_uint(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_15(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(1u,
+                                                                                              {||
+                                                                                                  deserialize_16(s)
+                                                                                              }))
+                                              }
+                                              3u {
+                                                syntax::ast::lit_float(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_12(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_17(s)
+                                                                                               }))
+                                              }
+                                              4u { syntax::ast::lit_nil }
+                                              5u {
+                                                syntax::ast::lit_bool(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_18(s)
+                                                                                              }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*uint*/
+fn deserialize_20<S: std::serialization::deserializer>(s: S) -> uint {
+    s.read_uint()
+}
+/*core::option::t<syntax::codemap::span>*/
+fn deserialize_26<S: std::serialization::deserializer>(s: S) ->
+   core::option::t<syntax::codemap::span> {
+    s.read_enum("core::option::t",
+
+
+                /*syntax::codemap::span*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { core::option::none }
+                                              1u {
+                                                core::option::some(s.read_enum_variant_arg(0u,
+                                                                                           {||
+                                                                                               deserialize_19(s)
+                                                                                           }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*{name: str,span: core::option::t<syntax::codemap::span>}*/
+fn deserialize_25<S: std::serialization::deserializer>(s: S) ->
+   {name: str, span: core::option::t<syntax::codemap::span>,} {
+
+    s.read_rec(
+
+
+               /*str*/
+
+               /*core::option::t<syntax::codemap::span>*/
+
+               {||
+                   {name:
+                        s.read_rec_field("name", 0u, {|| deserialize_12(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_26(s) }),}
+               })
+
+}
+/*{call_site: syntax::codemap::span,callie: {name: str,span: core::option::t<syntax::codemap::span>}}*/
+fn deserialize_24<S: std::serialization::deserializer>(s: S) ->
+   {call_site: syntax::codemap::span,
+    callie: {name: str, span: core::option::t<syntax::codemap::span>,},} {
+
+    s.read_rec(
+
+
+               /*syntax::codemap::span*/
+
+               /*{name: str,span: core::option::t<syntax::codemap::span>}*/
+
+               {||
+                   {call_site:
+                        s.read_rec_field("call_site", 0u,
+                                         {|| deserialize_19(s) }),
+                    callie:
+                        s.read_rec_field("callie", 1u,
+                                         {|| deserialize_25(s) }),}
+               })
+
+}
+/*syntax::codemap::expn_info_*/
+fn deserialize_23<S: std::serialization::deserializer>(s: S) ->
+   syntax::codemap::expn_info_ {
+    s.read_enum("syntax::codemap::expn_info_",
+
+                /*{call_site: syntax::codemap::span,callie: {name: str,span: core::option::t<syntax::codemap::span>}}*/
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::codemap::expanded_from(s.read_enum_variant_arg(0u,
+                                                                                                       {||
+                                                                                                           deserialize_24(s)
+                                                                                                       }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*@syntax::codemap::expn_info_*/
+fn deserialize_22<S: std::serialization::deserializer>(s: S) ->
+   @syntax::codemap::expn_info_ {
+
+    s.read_box(/*syntax::codemap::expn_info_*/{|| @deserialize_23(s) })
+
+}
+/*syntax::codemap::expn_info<@syntax::codemap::expn_info_>*/
+fn deserialize_21<S: std::serialization::deserializer>(s: S) ->
+   syntax::codemap::expn_info<@syntax::codemap::expn_info_> {
+    s.read_enum("core::option::t",
+
+
+                /*@syntax::codemap::expn_info_*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { core::option::none }
+                                              1u {
+                                                core::option::some(s.read_enum_variant_arg(0u,
+                                                                                           {||
+                                                                                               deserialize_22(s)
+                                                                                           }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::codemap::span*/
+fn deserialize_19<S: std::serialization::deserializer>(s: S) ->
+   syntax::codemap::span {
+
+    s.read_rec(
+
+
+               /*uint*/
+
+               /*uint*/
+
+               /*syntax::codemap::expn_info<@syntax::codemap::expn_info_>*/
+
+               {||
+                   {lo: s.read_rec_field("lo", 0u, {|| deserialize_20(s) }),
+                    hi: s.read_rec_field("hi", 1u, {|| deserialize_20(s) }),
+                    expn_info:
+                        s.read_rec_field("expn_info", 2u,
+                                         {|| deserialize_21(s) }),}
+               })
+
+}
+/*syntax::ast::lit*/
+fn deserialize_10<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::lit {
+
+    s.read_rec(
+
+
+               /*syntax::ast::lit_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_11(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*syntax::ast::meta_item_*/
+fn deserialize_7<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::meta_item_ {
+    s.read_enum("syntax::ast::meta_item_",
+                /*syntax::ast::ident*/
+
+                /*syntax::ast::ident*//*[@syntax::ast::meta_item]*/
+
+                /*syntax::ast::ident*//*syntax::ast::lit*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::meta_word(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_1(s)
+                                                                                               }))
+                                              }
+                                              1u {
+                                                syntax::ast::meta_list(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_1(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_8(s)
+                                                                                               }))
+                                              }
+                                              2u {
+                                                syntax::ast::meta_name_value(s.read_enum_variant_arg(0u,
+                                                                                                     {||
+                                                                                                         deserialize_1(s)
+                                                                                                     }),
+                                                                             s.read_enum_variant_arg(1u,
+                                                                                                     {||
+                                                                                                         deserialize_10(s)
+                                                                                                     }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::meta_item*/
+fn deserialize_6<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::meta_item {
+
+    s.read_rec(
+
+
+               /*syntax::ast::meta_item_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_7(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*syntax::ast::attribute_*/
+fn deserialize_4<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::attribute_ {
+
+    s.read_rec(
+
+
+               /*syntax::ast::attr_style*/
+
+               /*syntax::ast::meta_item*/
+
+               {||
+                   {style:
+                        s.read_rec_field("style", 0u, {|| deserialize_5(s) }),
+                    value:
+                        s.read_rec_field("value", 1u,
+                                         {|| deserialize_6(s) }),}
+               })
+
+}
+/*syntax::ast::attribute*/
+fn deserialize_3<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::attribute {
+
+    s.read_rec(
+
+
+               /*syntax::ast::attribute_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_4(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*[syntax::ast::attribute]*/
+fn deserialize_2<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::attribute] {
+    s.read_vec(
+
+               /*syntax::ast::attribute*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_3(s) })
+                                })
+               })
+}
+/*syntax::ast::node_id*/
+fn deserialize_27<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::node_id {
+    s.read_int()
+}
+/*syntax::ast::mutability*/
+fn deserialize_33<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::mutability {
+    s.read_enum("syntax::ast::mutability",
+
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::m_mutbl }
+                                              1u { syntax::ast::m_imm }
+                                              2u { syntax::ast::m_const }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::mt*/
+fn deserialize_32<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::mt {
+
+    s.read_rec(
+
+
+               /*@syntax::ast::ty*/
+
+               /*syntax::ast::mutability*/
+
+               {||
+                   {ty: s.read_rec_field("ty", 0u, {|| deserialize_29(s) }),
+                    mutbl:
+                        s.read_rec_field("mutbl", 1u,
+                                         {|| deserialize_33(s) }),}
+               })
+
+}
+/*syntax::ast::ty_field_*/
+fn deserialize_36<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ty_field_ {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ident*/
+
+               /*syntax::ast::mt*/
+
+               {||
+                   {ident:
+                        s.read_rec_field("ident", 0u, {|| deserialize_1(s) }),
+                    mt: s.read_rec_field("mt", 1u, {|| deserialize_32(s) }),}
+               })
+}
+/*syntax::ast::ty_field*/
+fn deserialize_35<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ty_field {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ty_field_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_36(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*[syntax::ast::ty_field]*/
+fn deserialize_34<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::ty_field] {
+    s.read_vec(
+
+               /*syntax::ast::ty_field*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_35(s) })
+                                })
+               })
+}
+/*syntax::ast::proto*/
+fn deserialize_37<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::proto {
+    s.read_enum("syntax::ast::proto",
+
+
+
+
+
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::proto_bare }
+                                              1u { syntax::ast::proto_any }
+                                              2u { syntax::ast::proto_uniq }
+                                              3u { syntax::ast::proto_box }
+                                              4u { syntax::ast::proto_block }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::rmode*/
+fn deserialize_42<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::rmode {
+    s.read_enum("syntax::ast::rmode",
+
+
+
+
+
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::by_ref }
+                                              1u { syntax::ast::by_val }
+                                              2u { syntax::ast::by_mutbl_ref }
+                                              3u { syntax::ast::by_move }
+                                              4u { syntax::ast::by_copy }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::mode<syntax::ast::rmode>*/
+fn deserialize_41<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::mode<syntax::ast::rmode> {
+    s.read_enum("syntax::ast::inferable",
+                /*syntax::ast::rmode*/
+
+                /*syntax::ast::node_id*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::expl(s.read_enum_variant_arg(0u,
+                                                                                          {||
+                                                                                              deserialize_42(s)
+                                                                                          }))
+                                              }
+                                              1u {
+                                                syntax::ast::infer(s.read_enum_variant_arg(0u,
+                                                                                           {||
+                                                                                               deserialize_27(s)
+                                                                                           }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::arg*/
+fn deserialize_40<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::arg {
+
+    s.read_rec(
+
+
+               /*syntax::ast::mode<syntax::ast::rmode>*/
+
+               /*@syntax::ast::ty*/
+
+               /*syntax::ast::ident*/
+
+               /*syntax::ast::node_id*/
+
+               {||
+                   {mode:
+                        s.read_rec_field("mode", 0u, {|| deserialize_41(s) }),
+                    ty: s.read_rec_field("ty", 1u, {|| deserialize_29(s) }),
+                    ident:
+                        s.read_rec_field("ident", 2u, {|| deserialize_1(s) }),
+                    id: s.read_rec_field("id", 3u, {|| deserialize_27(s) }),}
+               })
+}
+/*[syntax::ast::arg]*/
+fn deserialize_39<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::arg] {
+    s.read_vec(
+
+               /*syntax::ast::arg*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_40(s) })
+                                })
+               })
+}
+/*syntax::ast::purity*/
+fn deserialize_43<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::purity {
+    s.read_enum("syntax::ast::purity",
+
+
+
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::pure_fn }
+                                              1u { syntax::ast::unsafe_fn }
+                                              2u { syntax::ast::impure_fn }
+                                              3u { syntax::ast::crust_fn }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::ret_style*/
+fn deserialize_44<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ret_style {
+    s.read_enum("syntax::ast::ret_style",
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::noreturn }
+                                              1u { syntax::ast::return_val }
+                                            }
+                                        })
+                })
+}
+/*[syntax::ast::ident]*/
+fn deserialize_52<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::ident] {
+    s.read_vec(
+
+               /*syntax::ast::ident*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_1(s) })
+                                })
+               })
+}
+/*[@syntax::ast::ty]*/
+fn deserialize_53<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::ty] {
+    s.read_vec(
+
+               /*@syntax::ast::ty*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_29(s) })
+                                })
+               })
+}
+/*syntax::ast::path_*/
+fn deserialize_51<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::path_ {
+
+    s.read_rec(
+
+
+               /*bool*/
+
+               /*[syntax::ast::ident]*/
+
+               /*[@syntax::ast::ty]*/
+
+               {||
+                   {global:
+                        s.read_rec_field("global", 0u,
+                                         {|| deserialize_18(s) }),
+                    idents:
+                        s.read_rec_field("idents", 1u,
+                                         {|| deserialize_52(s) }),
+                    types:
+                        s.read_rec_field("types", 2u,
+                                         {|| deserialize_53(s) }),}
+               })
+
+}
+/*syntax::ast::path*/
+fn deserialize_50<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::path {
+
+    s.read_rec(
+
+
+               /*syntax::ast::path_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_51(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::path*/
+fn deserialize_49<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::path {
+
+    s.read_box(/*syntax::ast::path*/{|| @deserialize_50(s) })
+
+}
+/*@syntax::ast::lit*/
+fn deserialize_58<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::lit {
+
+    s.read_box(/*syntax::ast::lit*/{|| @deserialize_10(s) })
+
+}
+/*syntax::ast::constr_arg_general_<uint>*/
+fn deserialize_57<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::constr_arg_general_<uint> {
+    s.read_enum("syntax::ast::constr_arg_general_",
+
+
+                /*uint*/
+
+                /*@syntax::ast::lit*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::carg_base }
+                                              1u {
+                                                syntax::ast::carg_ident(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_20(s)
+                                                                                                }))
+                                              }
+                                              2u {
+                                                syntax::ast::carg_lit(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_58(s)
+                                                                                              }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}*/
+fn deserialize_56<S: std::serialization::deserializer>(s: S) ->
+   {node: syntax::ast::constr_arg_general_<uint>,
+    span: syntax::codemap::span,} {
+
+    s.read_rec(
+
+
+               /*syntax::ast::constr_arg_general_<uint>*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_57(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}*/
+fn deserialize_55<S: std::serialization::deserializer>(s: S) ->
+   @{node: syntax::ast::constr_arg_general_<uint>,
+     span: syntax::codemap::span,} {
+
+    s.read_box(
+               /*{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}*/
+               {|| @deserialize_56(s) })
+
+}
+/*[@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}]*/
+fn deserialize_54<S: std::serialization::deserializer>(s: S) ->
+   [@{node: syntax::ast::constr_arg_general_<uint>,
+      span: syntax::codemap::span,}] {
+    s.read_vec(
+
+
+               /*@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}*/
+
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_55(s) })
+                                })
+               })
+}
+/*{path: @syntax::ast::path,args: [@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}],id: syntax::ast::node_id}*/
+fn deserialize_48<S: std::serialization::deserializer>(s: S) ->
+   {path: @syntax::ast::path,
+    args:
+        [@{node: syntax::ast::constr_arg_general_<uint>,
+           span: syntax::codemap::span,}],
+    id: syntax::ast::node_id,} {
+
+    s.read_rec(
+
+
+               /*@syntax::ast::path*/
+
+
+               /*[@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}]*/
+
+
+               /*syntax::ast::node_id*/
+
+               {||
+                   {path:
+                        s.read_rec_field("path", 0u, {|| deserialize_49(s) }),
+                    args:
+                        s.read_rec_field("args", 1u, {|| deserialize_54(s) }),
+                    id: s.read_rec_field("id", 2u, {|| deserialize_27(s) }),}
+               })
+}
+/*syntax::ast::constr*/
+fn deserialize_47<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::constr {
+
+    s.read_rec(
+
+
+
+               /*{path: @syntax::ast::path,args: [@{node: syntax::ast::constr_arg_general_<uint>,span: syntax::codemap::span}],id: syntax::ast::node_id}*/
+
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_48(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::constr*/
+fn deserialize_46<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::constr {
+
+    s.read_box(/*syntax::ast::constr*/{|| @deserialize_47(s) })
+
+}
+/*[@syntax::ast::constr]*/
+fn deserialize_45<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::constr] {
+    s.read_vec(
+
+               /*@syntax::ast::constr*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_46(s) })
+                                })
+               })
+}
+/*syntax::ast::fn_decl*/
+fn deserialize_38<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::fn_decl {
+
+    s.read_rec(
+
+
+               /*[syntax::ast::arg]*/
+
+               /*@syntax::ast::ty*/
+
+               /*syntax::ast::purity*/
+
+               /*syntax::ast::ret_style*/
+
+               /*[@syntax::ast::constr]*/
+
+               {||
+                   {inputs:
+                        s.read_rec_field("inputs", 0u,
+                                         {|| deserialize_39(s) }),
+                    output:
+                        s.read_rec_field("output", 1u,
+                                         {|| deserialize_29(s) }),
+                    purity:
+                        s.read_rec_field("purity", 2u,
+                                         {|| deserialize_43(s) }),
+                    cf: s.read_rec_field("cf", 3u, {|| deserialize_44(s) }),
+                    constraints:
+                        s.read_rec_field("constraints", 4u,
+                                         {|| deserialize_45(s) }),}
+               })
+
+}
+/*syntax::ast::constr_arg_general_<@syntax::ast::path>*/
+fn deserialize_66<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::constr_arg_general_<@syntax::ast::path> {
+    s.read_enum("syntax::ast::constr_arg_general_",
+
+
+                /*@syntax::ast::path*/
+
+                /*@syntax::ast::lit*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::carg_base }
+                                              1u {
+                                                syntax::ast::carg_ident(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_49(s)
+                                                                                                }))
+                                              }
+                                              2u {
+                                                syntax::ast::carg_lit(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_58(s)
+                                                                                              }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/
+fn deserialize_65<S: std::serialization::deserializer>(s: S) ->
+   {node: syntax::ast::constr_arg_general_<@syntax::ast::path>,
+    span: syntax::codemap::span,} {
+
+    s.read_rec(
+
+
+               /*syntax::ast::constr_arg_general_<@syntax::ast::path>*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_66(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/
+fn deserialize_64<S: std::serialization::deserializer>(s: S) ->
+   @{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,
+     span: syntax::codemap::span,} {
+
+    s.read_box(
+               /*{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/
+               {|| @deserialize_65(s) })
+
+}
+/*[@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}]*/
+fn deserialize_63<S: std::serialization::deserializer>(s: S) ->
+   [@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,
+      span: syntax::codemap::span,}] {
+    s.read_vec(
+
+
+               /*@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}*/
+
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_64(s) })
+                                })
+               })
+}
+/*syntax::ast::ty_constr_*/
+fn deserialize_62<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ty_constr_ {
+
+    s.read_rec(
+
+
+               /*@syntax::ast::path*/
+
+
+               /*[@{node: syntax::ast::constr_arg_general_<@syntax::ast::path>,span: syntax::codemap::span}]*/
+
+
+               /*syntax::ast::node_id*/
+
+               {||
+                   {path:
+                        s.read_rec_field("path", 0u, {|| deserialize_49(s) }),
+                    args:
+                        s.read_rec_field("args", 1u, {|| deserialize_63(s) }),
+                    id: s.read_rec_field("id", 2u, {|| deserialize_27(s) }),}
+               })
+}
+/*syntax::ast::ty_constr*/
+fn deserialize_61<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ty_constr {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ty_constr_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_62(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::ty_constr*/
+fn deserialize_60<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::ty_constr {
+
+    s.read_box(/*syntax::ast::ty_constr*/{|| @deserialize_61(s) })
+
+}
+/*[@syntax::ast::ty_constr]*/
+fn deserialize_59<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::ty_constr] {
+    s.read_vec(
+
+               /*@syntax::ast::ty_constr*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_60(s) })
+                                })
+               })
+}
+/*[@syntax::ast::expr]*/
+fn deserialize_73<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::expr] {
+    s.read_vec(
+
+               /*@syntax::ast::expr*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_70(s) })
+                                })
+               })
+}
+/*syntax::ast::field_*/
+fn deserialize_76<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::field_ {
+
+    s.read_rec(
+
+
+               /*syntax::ast::mutability*/
+
+               /*syntax::ast::ident*/
+
+               /*@syntax::ast::expr*/
+
+               {||
+                   {mutbl:
+                        s.read_rec_field("mutbl", 0u,
+                                         {|| deserialize_33(s) }),
+                    ident:
+                        s.read_rec_field("ident", 1u, {|| deserialize_1(s) }),
+                    expr:
+                        s.read_rec_field("expr", 2u,
+                                         {|| deserialize_70(s) }),}
+               })
+
+}
+/*syntax::ast::field*/
+fn deserialize_75<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::field {
+
+    s.read_rec(
+
+
+               /*syntax::ast::field_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_76(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*[syntax::ast::field]*/
+fn deserialize_74<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::field] {
+    s.read_vec(
+
+               /*syntax::ast::field*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_75(s) })
+                                })
+               })
+}
+/*core::option::t<@syntax::ast::expr>*/
+fn deserialize_77<S: std::serialization::deserializer>(s: S) ->
+   core::option::t<@syntax::ast::expr> {
+    s.read_enum("core::option::t",
+
+
+                /*@syntax::ast::expr*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { core::option::none }
+                                              1u {
+                                                core::option::some(s.read_enum_variant_arg(0u,
+                                                                                           {||
+                                                                                               deserialize_70(s)
+                                                                                           }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*[core::option::t<@syntax::ast::expr>]*/
+fn deserialize_78<S: std::serialization::deserializer>(s: S) ->
+   [core::option::t<@syntax::ast::expr>] {
+    s.read_vec(
+
+               /*core::option::t<@syntax::ast::expr>*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_77(s) })
+                                })
+               })
+}
+/*syntax::ast::binop*/
+fn deserialize_79<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::binop {
+    s.read_enum("syntax::ast::binop",
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::add }
+                                              1u { syntax::ast::subtract }
+                                              2u { syntax::ast::mul }
+                                              3u { syntax::ast::div }
+                                              4u { syntax::ast::rem }
+                                              5u { syntax::ast::and }
+                                              6u { syntax::ast::or }
+                                              7u { syntax::ast::bitxor }
+                                              8u { syntax::ast::bitand }
+                                              9u { syntax::ast::bitor }
+                                              10u { syntax::ast::lsl }
+                                              11u { syntax::ast::lsr }
+                                              12u { syntax::ast::asr }
+                                              13u { syntax::ast::eq }
+                                              14u { syntax::ast::lt }
+                                              15u { syntax::ast::le }
+                                              16u { syntax::ast::ne }
+                                              17u { syntax::ast::ge }
+                                              18u { syntax::ast::gt }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::unop*/
+fn deserialize_80<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::unop {
+    s.read_enum("syntax::ast::unop",
+                /*syntax::ast::mutability*/
+
+                /*syntax::ast::mutability*/
+
+
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::box(s.read_enum_variant_arg(0u,
+                                                                                         {||
+                                                                                             deserialize_33(s)
+                                                                                         }))
+                                              }
+                                              1u {
+                                                syntax::ast::uniq(s.read_enum_variant_arg(0u,
+                                                                                          {||
+                                                                                              deserialize_33(s)
+                                                                                          }))
+                                              }
+                                              2u { syntax::ast::deref }
+                                              3u { syntax::ast::not }
+                                              4u { syntax::ast::neg }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::simple_path*/
+fn deserialize_92<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::simple_path {
+    s.read_vec(
+
+               /*syntax::ast::ident*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_1(s) })
+                                })
+               })
+}
+/*@syntax::ast::simple_path*/
+fn deserialize_91<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::simple_path {
+
+    s.read_box(/*syntax::ast::simple_path*/{|| @deserialize_92(s) })
+
+}
+/*syntax::ast::path_list_ident_*/
+fn deserialize_95<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::path_list_ident_ {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ident*/
+
+               /*syntax::ast::node_id*/
+
+               {||
+                   {name:
+                        s.read_rec_field("name", 0u, {|| deserialize_1(s) }),
+                    id: s.read_rec_field("id", 1u, {|| deserialize_27(s) }),}
+               })
+}
+/*syntax::ast::path_list_ident*/
+fn deserialize_94<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::path_list_ident {
+
+    s.read_rec(
+
+
+               /*syntax::ast::path_list_ident_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_95(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*[syntax::ast::path_list_ident]*/
+fn deserialize_93<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::path_list_ident] {
+    s.read_vec(
+
+               /*syntax::ast::path_list_ident*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_94(s) })
+                                })
+               })
+}
+/*syntax::ast::view_path_*/
+fn deserialize_90<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::view_path_ {
+    s.read_enum("syntax::ast::view_path_",
+                /*syntax::ast::ident*//*@syntax::ast::simple_path*/
+                /*syntax::ast::node_id*/
+
+                /*@syntax::ast::simple_path*//*syntax::ast::node_id*/
+
+                /*@syntax::ast::simple_path*/
+                /*[syntax::ast::path_list_ident]*//*syntax::ast::node_id*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::view_path_simple(s.read_enum_variant_arg(0u,
+                                                                                                      {||
+                                                                                                          deserialize_1(s)
+                                                                                                      }),
+                                                                              s.read_enum_variant_arg(1u,
+                                                                                                      {||
+                                                                                                          deserialize_91(s)
+                                                                                                      }),
+                                                                              s.read_enum_variant_arg(2u,
+                                                                                                      {||
+                                                                                                          deserialize_27(s)
+                                                                                                      }))
+                                              }
+                                              1u {
+                                                syntax::ast::view_path_glob(s.read_enum_variant_arg(0u,
+                                                                                                    {||
+                                                                                                        deserialize_91(s)
+                                                                                                    }),
+                                                                            s.read_enum_variant_arg(1u,
+                                                                                                    {||
+                                                                                                        deserialize_27(s)
+                                                                                                    }))
+                                              }
+                                              2u {
+                                                syntax::ast::view_path_list(s.read_enum_variant_arg(0u,
+                                                                                                    {||
+                                                                                                        deserialize_91(s)
+                                                                                                    }),
+                                                                            s.read_enum_variant_arg(1u,
+                                                                                                    {||
+                                                                                                        deserialize_93(s)
+                                                                                                    }),
+                                                                            s.read_enum_variant_arg(2u,
+                                                                                                    {||
+                                                                                                        deserialize_27(s)
+                                                                                                    }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::view_path*/
+fn deserialize_89<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::view_path {
+
+    s.read_rec(
+
+
+               /*syntax::ast::view_path_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_90(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::view_path*/
+fn deserialize_88<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::view_path {
+
+    s.read_box(/*syntax::ast::view_path*/{|| @deserialize_89(s) })
+
+}
+/*[@syntax::ast::view_path]*/
+fn deserialize_87<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::view_path] {
+    s.read_vec(
+
+               /*@syntax::ast::view_path*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_88(s) })
+                                })
+               })
+}
+/*syntax::ast::view_item_*/
+fn deserialize_86<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::view_item_ {
+    s.read_enum("syntax::ast::view_item_",
+                /*syntax::ast::ident*//*[@syntax::ast::meta_item]*/
+                /*syntax::ast::node_id*/
+
+                /*[@syntax::ast::view_path]*/
+
+                /*[@syntax::ast::view_path]*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::view_item_use(s.read_enum_variant_arg(0u,
+                                                                                                   {||
+                                                                                                       deserialize_1(s)
+                                                                                                   }),
+                                                                           s.read_enum_variant_arg(1u,
+                                                                                                   {||
+                                                                                                       deserialize_8(s)
+                                                                                                   }),
+                                                                           s.read_enum_variant_arg(2u,
+                                                                                                   {||
+                                                                                                       deserialize_27(s)
+                                                                                                   }))
+                                              }
+                                              1u {
+                                                syntax::ast::view_item_import(s.read_enum_variant_arg(0u,
+                                                                                                      {||
+                                                                                                          deserialize_87(s)
+                                                                                                      }))
+                                              }
+                                              2u {
+                                                syntax::ast::view_item_export(s.read_enum_variant_arg(0u,
+                                                                                                      {||
+                                                                                                          deserialize_87(s)
+                                                                                                      }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::view_item*/
+fn deserialize_85<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::view_item {
+
+    s.read_rec(
+
+
+               /*syntax::ast::view_item_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_86(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::view_item*/
+fn deserialize_84<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::view_item {
+
+    s.read_box(/*syntax::ast::view_item*/{|| @deserialize_85(s) })
+
+}
+/*[@syntax::ast::view_item]*/
+fn deserialize_83<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::view_item] {
+    s.read_vec(
+
+               /*@syntax::ast::view_item*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_84(s) })
+                                })
+               })
+}
+/*core::option::t<@syntax::ast::pat>*/
+fn deserialize_110<S: std::serialization::deserializer>(s: S) ->
+   core::option::t<@syntax::ast::pat> {
+    s.read_enum("core::option::t",
+
+
+                /*@syntax::ast::pat*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { core::option::none }
+                                              1u {
+                                                core::option::some(s.read_enum_variant_arg(0u,
+                                                                                           {||
+                                                                                               deserialize_107(s)
+                                                                                           }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*[@syntax::ast::pat]*/
+fn deserialize_111<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::pat] {
+    s.read_vec(
+
+               /*@syntax::ast::pat*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_107(s) })
+                                })
+               })
+}
+/*syntax::ast::field_pat*/
+fn deserialize_113<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::field_pat {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ident*/
+
+               /*@syntax::ast::pat*/
+
+               {||
+                   {ident:
+                        s.read_rec_field("ident", 0u, {|| deserialize_1(s) }),
+                    pat:
+                        s.read_rec_field("pat", 1u,
+                                         {|| deserialize_107(s) }),}
+               })
+
+}
+/*[syntax::ast::field_pat]*/
+fn deserialize_112<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::field_pat] {
+    s.read_vec(
+
+               /*syntax::ast::field_pat*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_113(s) })
+                                })
+               })
+}
+/*syntax::ast::pat_*/
+fn deserialize_109<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::pat_ {
+    s.read_enum("syntax::ast::pat_",
+
+
+                /*@syntax::ast::path*//*core::option::t<@syntax::ast::pat>*/
+
+                /*@syntax::ast::path*//*[@syntax::ast::pat]*/
+
+                /*[syntax::ast::field_pat]*//*bool*/
+
+                /*[@syntax::ast::pat]*/
+
+                /*@syntax::ast::pat*/
+
+                /*@syntax::ast::pat*/
+
+                /*@syntax::ast::expr*/
+
+                /*@syntax::ast::expr*//*@syntax::ast::expr*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::pat_wild }
+                                              1u {
+                                                syntax::ast::pat_ident(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_49(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_110(s)
+                                                                                               }))
+                                              }
+                                              2u {
+                                                syntax::ast::pat_enum(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_49(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(1u,
+                                                                                              {||
+                                                                                                  deserialize_111(s)
+                                                                                              }))
+                                              }
+                                              3u {
+                                                syntax::ast::pat_rec(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_112(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(1u,
+                                                                                             {||
+                                                                                                 deserialize_18(s)
+                                                                                             }))
+                                              }
+                                              4u {
+                                                syntax::ast::pat_tup(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_111(s)
+                                                                                             }))
+                                              }
+                                              5u {
+                                                syntax::ast::pat_box(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_107(s)
+                                                                                             }))
+                                              }
+                                              6u {
+                                                syntax::ast::pat_uniq(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_107(s)
+                                                                                              }))
+                                              }
+                                              7u {
+                                                syntax::ast::pat_lit(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_70(s)
+                                                                                             }))
+                                              }
+                                              8u {
+                                                syntax::ast::pat_range(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::pat*/
+fn deserialize_108<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::pat {
+
+    s.read_rec(
+
+
+               /*syntax::ast::node_id*/
+
+               /*syntax::ast::pat_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {id: s.read_rec_field("id", 0u, {|| deserialize_27(s) }),
+                    node:
+                        s.read_rec_field("node", 1u,
+                                         {|| deserialize_109(s) }),
+                    span:
+                        s.read_rec_field("span", 2u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::pat*/
+fn deserialize_107<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::pat {
+
+    s.read_box(/*syntax::ast::pat*/{|| @deserialize_108(s) })
+
+}
+/*syntax::ast::init_op*/
+fn deserialize_116<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::init_op {
+    s.read_enum("syntax::ast::init_op",
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::init_assign }
+                                              1u { syntax::ast::init_move }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::initializer*/
+fn deserialize_115<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::initializer {
+
+    s.read_rec(
+
+
+               /*syntax::ast::init_op*/
+
+               /*@syntax::ast::expr*/
+
+               {||
+                   {op: s.read_rec_field("op", 0u, {|| deserialize_116(s) }),
+                    expr:
+                        s.read_rec_field("expr", 1u,
+                                         {|| deserialize_70(s) }),}
+               })
+
+}
+/*core::option::t<syntax::ast::initializer>*/
+fn deserialize_114<S: std::serialization::deserializer>(s: S) ->
+   core::option::t<syntax::ast::initializer> {
+    s.read_enum("core::option::t",
+
+
+                /*syntax::ast::initializer*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { core::option::none }
+                                              1u {
+                                                core::option::some(s.read_enum_variant_arg(0u,
+                                                                                           {||
+                                                                                               deserialize_115(s)
+                                                                                           }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::local_*/
+fn deserialize_106<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::local_ {
+
+    s.read_rec(
+
+
+               /*@syntax::ast::ty*/
+
+               /*@syntax::ast::pat*/
+
+               /*core::option::t<syntax::ast::initializer>*/
+
+               /*syntax::ast::node_id*/
+
+               {||
+                   {ty: s.read_rec_field("ty", 0u, {|| deserialize_29(s) }),
+                    pat:
+                        s.read_rec_field("pat", 1u, {|| deserialize_107(s) }),
+                    init:
+                        s.read_rec_field("init", 2u,
+                                         {|| deserialize_114(s) }),
+                    id: s.read_rec_field("id", 3u, {|| deserialize_27(s) }),}
+               })
+}
+/*syntax::ast::local*/
+fn deserialize_105<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::local {
+
+    s.read_rec(
+
+
+               /*syntax::ast::local_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u,
+                                         {|| deserialize_106(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::local*/
+fn deserialize_104<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::local {
+
+    s.read_box(/*syntax::ast::local*/{|| @deserialize_105(s) })
+
+}
+/*[@syntax::ast::local]*/
+fn deserialize_103<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::local] {
+    s.read_vec(
+
+               /*@syntax::ast::local*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_104(s) })
+                                })
+               })
+}
+/*@syntax::ast::item*/
+fn deserialize_117<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::item {
+
+    s.read_box(/*syntax::ast::item*/{|| @deserialize_0(s) })
+
+}
+/*syntax::ast::decl_*/
+fn deserialize_102<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::decl_ {
+    s.read_enum("syntax::ast::decl_",
+                /*[@syntax::ast::local]*/
+
+                /*@syntax::ast::item*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::decl_local(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_103(s)
+                                                                                                }))
+                                              }
+                                              1u {
+                                                syntax::ast::decl_item(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_117(s)
+                                                                                               }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::decl*/
+fn deserialize_101<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::decl {
+
+    s.read_rec(
+
+
+               /*syntax::ast::decl_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u,
+                                         {|| deserialize_102(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::decl*/
+fn deserialize_100<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::decl {
+
+    s.read_box(/*syntax::ast::decl*/{|| @deserialize_101(s) })
+
+}
+/*syntax::ast::stmt_*/
+fn deserialize_99<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::stmt_ {
+    s.read_enum("syntax::ast::stmt_",
+                /*@syntax::ast::decl*//*syntax::ast::node_id*/
+
+                /*@syntax::ast::expr*//*syntax::ast::node_id*/
+
+                /*@syntax::ast::expr*//*syntax::ast::node_id*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::stmt_decl(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_100(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_27(s)
+                                                                                               }))
+                                              }
+                                              1u {
+                                                syntax::ast::stmt_expr(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_27(s)
+                                                                                               }))
+                                              }
+                                              2u {
+                                                syntax::ast::stmt_semi(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_27(s)
+                                                                                               }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::stmt*/
+fn deserialize_98<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::stmt {
+
+    s.read_rec(
+
+
+               /*syntax::ast::stmt_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_99(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::stmt*/
+fn deserialize_97<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::stmt {
+
+    s.read_box(/*syntax::ast::stmt*/{|| @deserialize_98(s) })
+
+}
+/*[@syntax::ast::stmt]*/
+fn deserialize_96<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::stmt] {
+    s.read_vec(
+
+               /*@syntax::ast::stmt*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i, {|| deserialize_97(s) })
+                                })
+               })
+}
+/*syntax::ast::blk_check_mode*/
+fn deserialize_118<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::blk_check_mode {
+    s.read_enum("syntax::ast::blk_check_mode",
+
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::default_blk }
+                                              1u {
+                                                syntax::ast::unchecked_blk
+                                              }
+                                              2u { syntax::ast::unsafe_blk }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::blk_*/
+fn deserialize_82<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::blk_ {
+
+    s.read_rec(
+
+
+               /*[@syntax::ast::view_item]*/
+
+               /*[@syntax::ast::stmt]*/
+
+               /*core::option::t<@syntax::ast::expr>*/
+
+               /*syntax::ast::node_id*/
+
+               /*syntax::ast::blk_check_mode*/
+
+               {||
+                   {view_items:
+                        s.read_rec_field("view_items", 0u,
+                                         {|| deserialize_83(s) }),
+                    stmts:
+                        s.read_rec_field("stmts", 1u,
+                                         {|| deserialize_96(s) }),
+                    expr:
+                        s.read_rec_field("expr", 2u, {|| deserialize_77(s) }),
+                    id: s.read_rec_field("id", 3u, {|| deserialize_27(s) }),
+                    rules:
+                        s.read_rec_field("rules", 4u,
+                                         {|| deserialize_118(s) }),}
+               })
+
+}
+/*syntax::ast::blk*/
+fn deserialize_81<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::blk {
+
+    s.read_rec(
+
+
+               /*syntax::ast::blk_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_82(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*syntax::ast::arm*/
+fn deserialize_120<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::arm {
+
+    s.read_rec(
+
+
+               /*[@syntax::ast::pat]*/
+
+               /*core::option::t<@syntax::ast::expr>*/
+
+               /*syntax::ast::blk*/
+
+               {||
+                   {pats:
+                        s.read_rec_field("pats", 0u,
+                                         {|| deserialize_111(s) }),
+                    guard:
+                        s.read_rec_field("guard", 1u,
+                                         {|| deserialize_77(s) }),
+                    body:
+                        s.read_rec_field("body", 2u,
+                                         {|| deserialize_81(s) }),}
+               })
+
+}
+/*[syntax::ast::arm]*/
+fn deserialize_119<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::arm] {
+    s.read_vec(
+
+               /*syntax::ast::arm*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_120(s) })
+                                })
+               })
+}
+/*syntax::ast::alt_mode*/
+fn deserialize_121<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::alt_mode {
+    s.read_enum("syntax::ast::alt_mode",
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::alt_check }
+                                              1u {
+                                                syntax::ast::alt_exhaustive
+                                              }
+                                            }
+                                        })
+                })
+}
+/*int*/
+fn deserialize_127<S: std::serialization::deserializer>(s: S) -> int {
+    s.read_int()
+}
+/*syntax::ast::capture_item*/
+fn deserialize_126<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::capture_item {
+
+    s.read_rec(
+
+
+               /*int*/
+
+               /*syntax::ast::ident*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {id: s.read_rec_field("id", 0u, {|| deserialize_127(s) }),
+                    name:
+                        s.read_rec_field("name", 1u, {|| deserialize_1(s) }),
+                    span:
+                        s.read_rec_field("span", 2u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::capture_item*/
+fn deserialize_125<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::capture_item {
+
+    s.read_box(/*syntax::ast::capture_item*/{|| @deserialize_126(s) })
+
+}
+/*[@syntax::ast::capture_item]*/
+fn deserialize_124<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::capture_item] {
+    s.read_vec(
+
+               /*@syntax::ast::capture_item*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_125(s) })
+                                })
+               })
+}
+/*syntax::ast::capture_clause*/
+fn deserialize_123<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::capture_clause {
+
+    s.read_rec(
+
+
+               /*[@syntax::ast::capture_item]*/
+
+               /*[@syntax::ast::capture_item]*/
+
+               {||
+                   {copies:
+                        s.read_rec_field("copies", 0u,
+                                         {|| deserialize_124(s) }),
+                    moves:
+                        s.read_rec_field("moves", 1u,
+                                         {|| deserialize_124(s) }),}
+               })
+
+}
+/*@syntax::ast::capture_clause*/
+fn deserialize_122<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::capture_clause {
+
+    s.read_box(/*syntax::ast::capture_clause*/{|| @deserialize_123(s) })
+
+}
+/*syntax::ast::expr_check_mode*/
+fn deserialize_128<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::expr_check_mode {
+    s.read_enum("syntax::ast::expr_check_mode",
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::claimed_expr }
+                                              1u { syntax::ast::checked_expr }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::expr_*/
+fn deserialize_72<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::expr_ {
+    s.read_enum("syntax::ast::expr_",
+                /*[@syntax::ast::expr]*//*syntax::ast::mutability*/
+
+                /*[syntax::ast::field]*/
+                /*core::option::t<@syntax::ast::expr>*/
+
+                /*@syntax::ast::expr*//*[@syntax::ast::expr]*//*bool*/
+
+                /*[@syntax::ast::expr]*/
+
+                /*@syntax::ast::expr*/
+                /*[core::option::t<@syntax::ast::expr>]*/
+
+                /*syntax::ast::binop*//*@syntax::ast::expr*/
+                /*@syntax::ast::expr*/
+
+                /*syntax::ast::unop*//*@syntax::ast::expr*/
+
+                /*@syntax::ast::lit*/
+
+                /*@syntax::ast::expr*//*@syntax::ast::ty*/
+
+                /*@syntax::ast::expr*//*syntax::ast::blk*/
+                /*core::option::t<@syntax::ast::expr>*/
+
+                /*@syntax::ast::expr*//*syntax::ast::blk*/
+
+                /*@syntax::ast::local*//*@syntax::ast::expr*/
+                /*syntax::ast::blk*/
+
+                /*syntax::ast::blk*//*@syntax::ast::expr*/
+
+                /*@syntax::ast::expr*//*[syntax::ast::arm]*/
+                /*syntax::ast::alt_mode*/
+
+                /*syntax::ast::proto*//*syntax::ast::fn_decl*/
+                /*syntax::ast::blk*//*@syntax::ast::capture_clause*/
+
+                /*syntax::ast::fn_decl*//*syntax::ast::blk*/
+
+                /*syntax::ast::blk*/
+
+                /*@syntax::ast::expr*/
+
+                /*@syntax::ast::expr*//*@syntax::ast::expr*/
+
+                /*@syntax::ast::expr*//*@syntax::ast::expr*/
+
+                /*@syntax::ast::expr*//*@syntax::ast::expr*/
+
+                /*syntax::ast::binop*//*@syntax::ast::expr*/
+                /*@syntax::ast::expr*/
+
+                /*@syntax::ast::expr*//*syntax::ast::ident*/
+                /*[@syntax::ast::ty]*/
+
+                /*@syntax::ast::expr*//*@syntax::ast::expr*/
+
+                /*@syntax::ast::path*/
+
+                /*core::option::t<@syntax::ast::expr>*/
+
+
+
+
+
+                /*core::option::t<@syntax::ast::expr>*/
+
+                /*@syntax::ast::expr*/
+
+                /*int*//*@syntax::ast::expr*//*@syntax::ast::expr*/
+
+                /*@syntax::ast::expr*/
+
+                /*syntax::ast::expr_check_mode*//*@syntax::ast::expr*/
+
+                /*@syntax::ast::expr*//*syntax::ast::blk*/
+                /*core::option::t<@syntax::ast::expr>*/
+
+                /*syntax::ast::mac*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::expr_vec(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_73(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(1u,
+                                                                                              {||
+                                                                                                  deserialize_33(s)
+                                                                                              }))
+                                              }
+                                              1u {
+                                                syntax::ast::expr_rec(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_74(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(1u,
+                                                                                              {||
+                                                                                                  deserialize_77(s)
+                                                                                              }))
+                                              }
+                                              2u {
+                                                syntax::ast::expr_call(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_73(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(2u,
+                                                                                               {||
+                                                                                                   deserialize_18(s)
+                                                                                               }))
+                                              }
+                                              3u {
+                                                syntax::ast::expr_tup(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_73(s)
+                                                                                              }))
+                                              }
+                                              4u {
+                                                syntax::ast::expr_bind(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_78(s)
+                                                                                               }))
+                                              }
+                                              5u {
+                                                syntax::ast::expr_binary(s.read_enum_variant_arg(0u,
+                                                                                                 {||
+                                                                                                     deserialize_79(s)
+                                                                                                 }),
+                                                                         s.read_enum_variant_arg(1u,
+                                                                                                 {||
+                                                                                                     deserialize_70(s)
+                                                                                                 }),
+                                                                         s.read_enum_variant_arg(2u,
+                                                                                                 {||
+                                                                                                     deserialize_70(s)
+                                                                                                 }))
+                                              }
+                                              6u {
+                                                syntax::ast::expr_unary(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_80(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(1u,
+                                                                                                {||
+                                                                                                    deserialize_70(s)
+                                                                                                }))
+                                              }
+                                              7u {
+                                                syntax::ast::expr_lit(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_58(s)
+                                                                                              }))
+                                              }
+                                              8u {
+                                                syntax::ast::expr_cast(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_29(s)
+                                                                                               }))
+                                              }
+                                              9u {
+                                                syntax::ast::expr_if(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_70(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(1u,
+                                                                                             {||
+                                                                                                 deserialize_81(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(2u,
+                                                                                             {||
+                                                                                                 deserialize_77(s)
+                                                                                             }))
+                                              }
+                                              10u {
+                                                syntax::ast::expr_while(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_70(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(1u,
+                                                                                                {||
+                                                                                                    deserialize_81(s)
+                                                                                                }))
+                                              }
+                                              11u {
+                                                syntax::ast::expr_for(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_104(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(1u,
+                                                                                              {||
+                                                                                                  deserialize_70(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(2u,
+                                                                                              {||
+                                                                                                  deserialize_81(s)
+                                                                                              }))
+                                              }
+                                              12u {
+                                                syntax::ast::expr_do_while(s.read_enum_variant_arg(0u,
+                                                                                                   {||
+                                                                                                       deserialize_81(s)
+                                                                                                   }),
+                                                                           s.read_enum_variant_arg(1u,
+                                                                                                   {||
+                                                                                                       deserialize_70(s)
+                                                                                                   }))
+                                              }
+                                              13u {
+                                                syntax::ast::expr_alt(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_70(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(1u,
+                                                                                              {||
+                                                                                                  deserialize_119(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(2u,
+                                                                                              {||
+                                                                                                  deserialize_121(s)
+                                                                                              }))
+                                              }
+                                              14u {
+                                                syntax::ast::expr_fn(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_37(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(1u,
+                                                                                             {||
+                                                                                                 deserialize_38(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(2u,
+                                                                                             {||
+                                                                                                 deserialize_81(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(3u,
+                                                                                             {||
+                                                                                                 deserialize_122(s)
+                                                                                             }))
+                                              }
+                                              15u {
+                                                syntax::ast::expr_fn_block(s.read_enum_variant_arg(0u,
+                                                                                                   {||
+                                                                                                       deserialize_38(s)
+                                                                                                   }),
+                                                                           s.read_enum_variant_arg(1u,
+                                                                                                   {||
+                                                                                                       deserialize_81(s)
+                                                                                                   }))
+                                              }
+                                              16u {
+                                                syntax::ast::expr_block(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_81(s)
+                                                                                                }))
+                                              }
+                                              17u {
+                                                syntax::ast::expr_copy(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }))
+                                              }
+                                              18u {
+                                                syntax::ast::expr_move(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }))
+                                              }
+                                              19u {
+                                                syntax::ast::expr_assign(s.read_enum_variant_arg(0u,
+                                                                                                 {||
+                                                                                                     deserialize_70(s)
+                                                                                                 }),
+                                                                         s.read_enum_variant_arg(1u,
+                                                                                                 {||
+                                                                                                     deserialize_70(s)
+                                                                                                 }))
+                                              }
+                                              20u {
+                                                syntax::ast::expr_swap(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_70(s)
+                                                                                               }))
+                                              }
+                                              21u {
+                                                syntax::ast::expr_assign_op(s.read_enum_variant_arg(0u,
+                                                                                                    {||
+                                                                                                        deserialize_79(s)
+                                                                                                    }),
+                                                                            s.read_enum_variant_arg(1u,
+                                                                                                    {||
+                                                                                                        deserialize_70(s)
+                                                                                                    }),
+                                                                            s.read_enum_variant_arg(2u,
+                                                                                                    {||
+                                                                                                        deserialize_70(s)
+                                                                                                    }))
+                                              }
+                                              22u {
+                                                syntax::ast::expr_field(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_70(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(1u,
+                                                                                                {||
+                                                                                                    deserialize_1(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(2u,
+                                                                                                {||
+                                                                                                    deserialize_53(s)
+                                                                                                }))
+                                              }
+                                              23u {
+                                                syntax::ast::expr_index(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_70(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(1u,
+                                                                                                {||
+                                                                                                    deserialize_70(s)
+                                                                                                }))
+                                              }
+                                              24u {
+                                                syntax::ast::expr_path(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_49(s)
+                                                                                               }))
+                                              }
+                                              25u {
+                                                syntax::ast::expr_fail(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_77(s)
+                                                                                               }))
+                                              }
+                                              26u { syntax::ast::expr_break }
+                                              27u { syntax::ast::expr_cont }
+                                              28u {
+                                                syntax::ast::expr_ret(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_77(s)
+                                                                                              }))
+                                              }
+                                              29u {
+                                                syntax::ast::expr_be(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_70(s)
+                                                                                             }))
+                                              }
+                                              30u {
+                                                syntax::ast::expr_log(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_127(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(1u,
+                                                                                              {||
+                                                                                                  deserialize_70(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(2u,
+                                                                                              {||
+                                                                                                  deserialize_70(s)
+                                                                                              }))
+                                              }
+                                              31u {
+                                                syntax::ast::expr_assert(s.read_enum_variant_arg(0u,
+                                                                                                 {||
+                                                                                                     deserialize_70(s)
+                                                                                                 }))
+                                              }
+                                              32u {
+                                                syntax::ast::expr_check(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_128(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(1u,
+                                                                                                {||
+                                                                                                    deserialize_70(s)
+                                                                                                }))
+                                              }
+                                              33u {
+                                                syntax::ast::expr_if_check(s.read_enum_variant_arg(0u,
+                                                                                                   {||
+                                                                                                       deserialize_70(s)
+                                                                                                   }),
+                                                                           s.read_enum_variant_arg(1u,
+                                                                                                   {||
+                                                                                                       deserialize_81(s)
+                                                                                                   }),
+                                                                           s.read_enum_variant_arg(2u,
+                                                                                                   {||
+                                                                                                       deserialize_77(s)
+                                                                                                   }))
+                                              }
+                                              34u {
+                                                syntax::ast::expr_mac(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_67(s)
+                                                                                              }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::expr*/
+fn deserialize_71<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::expr {
+
+    s.read_rec(
+
+
+               /*syntax::ast::node_id*/
+
+               /*syntax::ast::expr_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {id: s.read_rec_field("id", 0u, {|| deserialize_27(s) }),
+                    node:
+                        s.read_rec_field("node", 1u, {|| deserialize_72(s) }),
+                    span:
+                        s.read_rec_field("span", 2u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::expr*/
+fn deserialize_70<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::expr {
+
+    s.read_box(/*syntax::ast::expr*/{|| @deserialize_71(s) })
+
+}
+/*syntax::ast::mac_arg<@syntax::ast::expr>*/
+fn deserialize_69<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::mac_arg<@syntax::ast::expr> {
+    s.read_enum("core::option::t",
+
+
+                /*@syntax::ast::expr*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { core::option::none }
+                                              1u {
+                                                core::option::some(s.read_enum_variant_arg(0u,
+                                                                                           {||
+                                                                                               deserialize_70(s)
+                                                                                           }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::mac_body_*/
+fn deserialize_130<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::mac_body_ {
+
+    s.read_rec(
+
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {span:
+                        s.read_rec_field("span", 0u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*syntax::ast::mac_body<syntax::ast::mac_body_>*/
+fn deserialize_129<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::mac_body<syntax::ast::mac_body_> {
+    s.read_enum("core::option::t",
+
+
+                /*syntax::ast::mac_body_*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { core::option::none }
+                                              1u {
+                                                core::option::some(s.read_enum_variant_arg(0u,
+                                                                                           {||
+                                                                                               deserialize_130(s)
+                                                                                           }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::mac_*/
+fn deserialize_68<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::mac_ {
+    s.read_enum("syntax::ast::mac_",
+                /*@syntax::ast::path*/
+                /*syntax::ast::mac_arg<@syntax::ast::expr>*/
+                /*syntax::ast::mac_body<syntax::ast::mac_body_>*/
+
+                /*@syntax::ast::ty*/
+
+                /*syntax::ast::blk*/
+
+
+
+                /*syntax::codemap::span*//*@syntax::ast::expr*/
+
+                /*uint*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::mac_invoc(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_49(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_69(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(2u,
+                                                                                               {||
+                                                                                                   deserialize_129(s)
+                                                                                               }))
+                                              }
+                                              1u {
+                                                syntax::ast::mac_embed_type(s.read_enum_variant_arg(0u,
+                                                                                                    {||
+                                                                                                        deserialize_29(s)
+                                                                                                    }))
+                                              }
+                                              2u {
+                                                syntax::ast::mac_embed_block(s.read_enum_variant_arg(0u,
+                                                                                                     {||
+                                                                                                         deserialize_81(s)
+                                                                                                     }))
+                                              }
+                                              3u { syntax::ast::mac_ellipsis }
+                                              4u {
+                                                syntax::ast::mac_aq(s.read_enum_variant_arg(0u,
+                                                                                            {||
+                                                                                                deserialize_19(s)
+                                                                                            }),
+                                                                    s.read_enum_variant_arg(1u,
+                                                                                            {||
+                                                                                                deserialize_70(s)
+                                                                                            }))
+                                              }
+                                              5u {
+                                                syntax::ast::mac_var(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_20(s)
+                                                                                             }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::mac*/
+fn deserialize_67<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::mac {
+
+    s.read_rec(
+
+
+               /*syntax::ast::mac_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_68(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*syntax::ast::ty_*/
+fn deserialize_31<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ty_ {
+    s.read_enum("syntax::ast::ty_",
+
+
+
+
+                /*syntax::ast::mt*/
+
+                /*syntax::ast::mt*/
+
+                /*syntax::ast::mt*/
+
+                /*syntax::ast::mt*/
+
+                /*[syntax::ast::ty_field]*/
+
+                /*syntax::ast::proto*//*syntax::ast::fn_decl*/
+
+                /*[@syntax::ast::ty]*/
+
+                /*@syntax::ast::path*//*syntax::ast::node_id*/
+
+                /*@syntax::ast::ty*//*[@syntax::ast::ty_constr]*/
+
+                /*syntax::ast::mac*/
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::ty_nil }
+                                              1u { syntax::ast::ty_bot }
+                                              2u {
+                                                syntax::ast::ty_box(s.read_enum_variant_arg(0u,
+                                                                                            {||
+                                                                                                deserialize_32(s)
+                                                                                            }))
+                                              }
+                                              3u {
+                                                syntax::ast::ty_uniq(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_32(s)
+                                                                                             }))
+                                              }
+                                              4u {
+                                                syntax::ast::ty_vec(s.read_enum_variant_arg(0u,
+                                                                                            {||
+                                                                                                deserialize_32(s)
+                                                                                            }))
+                                              }
+                                              5u {
+                                                syntax::ast::ty_ptr(s.read_enum_variant_arg(0u,
+                                                                                            {||
+                                                                                                deserialize_32(s)
+                                                                                            }))
+                                              }
+                                              6u {
+                                                syntax::ast::ty_rec(s.read_enum_variant_arg(0u,
+                                                                                            {||
+                                                                                                deserialize_34(s)
+                                                                                            }))
+                                              }
+                                              7u {
+                                                syntax::ast::ty_fn(s.read_enum_variant_arg(0u,
+                                                                                           {||
+                                                                                               deserialize_37(s)
+                                                                                           }),
+                                                                   s.read_enum_variant_arg(1u,
+                                                                                           {||
+                                                                                               deserialize_38(s)
+                                                                                           }))
+                                              }
+                                              8u {
+                                                syntax::ast::ty_tup(s.read_enum_variant_arg(0u,
+                                                                                            {||
+                                                                                                deserialize_53(s)
+                                                                                            }))
+                                              }
+                                              9u {
+                                                syntax::ast::ty_path(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_49(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(1u,
+                                                                                             {||
+                                                                                                 deserialize_27(s)
+                                                                                             }))
+                                              }
+                                              10u {
+                                                syntax::ast::ty_constr(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_29(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_59(s)
+                                                                                               }))
+                                              }
+                                              11u {
+                                                syntax::ast::ty_mac(s.read_enum_variant_arg(0u,
+                                                                                            {||
+                                                                                                deserialize_67(s)
+                                                                                            }))
+                                              }
+                                              12u { syntax::ast::ty_infer }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::ty*/
+fn deserialize_30<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ty {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ty_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u, {|| deserialize_31(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::ty*/
+fn deserialize_29<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::ty {
+
+    s.read_box(/*syntax::ast::ty*/{|| @deserialize_30(s) })
+
+}
+/*syntax::ast::ty_param_bound*/
+fn deserialize_135<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ty_param_bound {
+    s.read_enum("syntax::ast::ty_param_bound",
+
+
+
+
+                /*@syntax::ast::ty*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::bound_copy }
+                                              1u { syntax::ast::bound_send }
+                                              2u {
+                                                syntax::ast::bound_iface(s.read_enum_variant_arg(0u,
+                                                                                                 {||
+                                                                                                     deserialize_29(s)
+                                                                                                 }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*[syntax::ast::ty_param_bound]*/
+fn deserialize_134<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::ty_param_bound] {
+    s.read_vec(
+
+               /*syntax::ast::ty_param_bound*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_135(s) })
+                                })
+               })
+}
+/*@[syntax::ast::ty_param_bound]*/
+fn deserialize_133<S: std::serialization::deserializer>(s: S) ->
+   @[syntax::ast::ty_param_bound] {
+
+    s.read_box(/*[syntax::ast::ty_param_bound]*/{|| @deserialize_134(s) })
+
+}
+/*syntax::ast::ty_param*/
+fn deserialize_132<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ty_param {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ident*/
+
+               /*syntax::ast::node_id*/
+
+               /*@[syntax::ast::ty_param_bound]*/
+
+               {||
+                   {ident:
+                        s.read_rec_field("ident", 0u, {|| deserialize_1(s) }),
+                    id: s.read_rec_field("id", 1u, {|| deserialize_27(s) }),
+                    bounds:
+                        s.read_rec_field("bounds", 2u,
+                                         {|| deserialize_133(s) }),}
+               })
+
+}
+/*[syntax::ast::ty_param]*/
+fn deserialize_131<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::ty_param] {
+    s.read_vec(
+
+               /*syntax::ast::ty_param*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_132(s) })
+                                })
+               })
+}
+/*[@syntax::ast::item]*/
+fn deserialize_137<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::item] {
+    s.read_vec(
+
+               /*@syntax::ast::item*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_117(s) })
+                                })
+               })
+}
+/*syntax::ast::_mod*/
+fn deserialize_136<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::_mod {
+
+    s.read_rec(
+
+
+               /*[@syntax::ast::view_item]*/
+
+               /*[@syntax::ast::item]*/
+
+               {||
+                   {view_items:
+                        s.read_rec_field("view_items", 0u,
+                                         {|| deserialize_83(s) }),
+                    items:
+                        s.read_rec_field("items", 1u,
+                                         {|| deserialize_137(s) }),}
+               })
+
+}
+/*syntax::ast::native_item_*/
+fn deserialize_142<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::native_item_ {
+    s.read_enum("syntax::ast::native_item_",
+                /*syntax::ast::fn_decl*//*[syntax::ast::ty_param]*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::native_item_fn(s.read_enum_variant_arg(0u,
+                                                                                                    {||
+                                                                                                        deserialize_38(s)
+                                                                                                    }),
+                                                                            s.read_enum_variant_arg(1u,
+                                                                                                    {||
+                                                                                                        deserialize_131(s)
+                                                                                                    }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::native_item*/
+fn deserialize_141<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::native_item {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ident*/
+
+               /*[syntax::ast::attribute]*/
+
+               /*syntax::ast::native_item_*/
+
+               /*syntax::ast::node_id*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {ident:
+                        s.read_rec_field("ident", 0u, {|| deserialize_1(s) }),
+                    attrs:
+                        s.read_rec_field("attrs", 1u, {|| deserialize_2(s) }),
+                    node:
+                        s.read_rec_field("node", 2u,
+                                         {|| deserialize_142(s) }),
+                    id: s.read_rec_field("id", 3u, {|| deserialize_27(s) }),
+                    span:
+                        s.read_rec_field("span", 4u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::native_item*/
+fn deserialize_140<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::native_item {
+
+    s.read_box(/*syntax::ast::native_item*/{|| @deserialize_141(s) })
+
+}
+/*[@syntax::ast::native_item]*/
+fn deserialize_139<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::native_item] {
+    s.read_vec(
+
+               /*@syntax::ast::native_item*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_140(s) })
+                                })
+               })
+}
+/*syntax::ast::native_mod*/
+fn deserialize_138<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::native_mod {
+
+    s.read_rec(
+
+
+               /*[@syntax::ast::view_item]*/
+
+               /*[@syntax::ast::native_item]*/
+
+               {||
+                   {view_items:
+                        s.read_rec_field("view_items", 0u,
+                                         {|| deserialize_83(s) }),
+                    items:
+                        s.read_rec_field("items", 1u,
+                                         {|| deserialize_139(s) }),}
+               })
+
+}
+/*syntax::ast::variant_arg*/
+fn deserialize_147<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::variant_arg {
+
+    s.read_rec(
+
+
+               /*@syntax::ast::ty*/
+
+               /*syntax::ast::node_id*/
+
+               {||
+                   {ty: s.read_rec_field("ty", 0u, {|| deserialize_29(s) }),
+                    id: s.read_rec_field("id", 1u, {|| deserialize_27(s) }),}
+               })
+}
+/*[syntax::ast::variant_arg]*/
+fn deserialize_146<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::variant_arg] {
+    s.read_vec(
+
+               /*syntax::ast::variant_arg*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_147(s) })
+                                })
+               })
+}
+/*syntax::ast::variant_*/
+fn deserialize_145<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::variant_ {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ident*/
+
+               /*[syntax::ast::attribute]*/
+
+               /*[syntax::ast::variant_arg]*/
+
+               /*syntax::ast::node_id*/
+
+               /*core::option::t<@syntax::ast::expr>*/
+
+               {||
+                   {name:
+                        s.read_rec_field("name", 0u, {|| deserialize_1(s) }),
+                    attrs:
+                        s.read_rec_field("attrs", 1u, {|| deserialize_2(s) }),
+                    args:
+                        s.read_rec_field("args", 2u,
+                                         {|| deserialize_146(s) }),
+                    id: s.read_rec_field("id", 3u, {|| deserialize_27(s) }),
+                    disr_expr:
+                        s.read_rec_field("disr_expr", 4u,
+                                         {|| deserialize_77(s) }),}
+               })
+
+}
+/*syntax::ast::variant*/
+fn deserialize_144<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::variant {
+
+    s.read_rec(
+
+
+               /*syntax::ast::variant_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u,
+                                         {|| deserialize_145(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*[syntax::ast::variant]*/
+fn deserialize_143<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::variant] {
+    s.read_vec(
+
+               /*syntax::ast::variant*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_144(s) })
+                                })
+               })
+}
+/*syntax::ast::privacy*/
+fn deserialize_152<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::privacy {
+    s.read_enum("syntax::ast::privacy",
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { syntax::ast::priv }
+                                              1u { syntax::ast::pub }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::class_mutability*/
+fn deserialize_154<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::class_mutability {
+    s.read_enum("syntax::ast::class_mutability",
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::class_mutable
+                                              }
+                                              1u {
+                                                syntax::ast::class_immutable
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::class_member*/
+fn deserialize_153<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::class_member {
+    s.read_enum("syntax::ast::class_member",
+                /*syntax::ast::ident*//*@syntax::ast::ty*/
+                /*syntax::ast::class_mutability*//*syntax::ast::node_id*/
+
+                /*@syntax::ast::item*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::instance_var(s.read_enum_variant_arg(0u,
+                                                                                                  {||
+                                                                                                      deserialize_1(s)
+                                                                                                  }),
+                                                                          s.read_enum_variant_arg(1u,
+                                                                                                  {||
+                                                                                                      deserialize_29(s)
+                                                                                                  }),
+                                                                          s.read_enum_variant_arg(2u,
+                                                                                                  {||
+                                                                                                      deserialize_154(s)
+                                                                                                  }),
+                                                                          s.read_enum_variant_arg(3u,
+                                                                                                  {||
+                                                                                                      deserialize_27(s)
+                                                                                                  }))
+                                              }
+                                              1u {
+                                                syntax::ast::class_method(s.read_enum_variant_arg(0u,
+                                                                                                  {||
+                                                                                                      deserialize_117(s)
+                                                                                                  }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::class_item_*/
+fn deserialize_151<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::class_item_ {
+
+    s.read_rec(
+
+
+               /*syntax::ast::privacy*/
+
+               /*syntax::ast::class_member*/
+
+               {||
+                   {privacy:
+                        s.read_rec_field("privacy", 0u,
+                                         {|| deserialize_152(s) }),
+                    decl:
+                        s.read_rec_field("decl", 1u,
+                                         {|| deserialize_153(s) }),}
+               })
+
+}
+/*syntax::ast::class_item*/
+fn deserialize_150<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::class_item {
+
+    s.read_rec(
+
+
+               /*syntax::ast::class_item_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {node:
+                        s.read_rec_field("node", 0u,
+                                         {|| deserialize_151(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::class_item*/
+fn deserialize_149<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::class_item {
+
+    s.read_box(/*syntax::ast::class_item*/{|| @deserialize_150(s) })
+
+}
+/*[@syntax::ast::class_item]*/
+fn deserialize_148<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::class_item] {
+    s.read_vec(
+
+               /*@syntax::ast::class_item*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_149(s) })
+                                })
+               })
+}
+/*syntax::ast::ty_method*/
+fn deserialize_156<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::ty_method {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ident*/
+
+               /*[syntax::ast::attribute]*/
+
+               /*syntax::ast::fn_decl*/
+
+               /*[syntax::ast::ty_param]*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {ident:
+                        s.read_rec_field("ident", 0u, {|| deserialize_1(s) }),
+                    attrs:
+                        s.read_rec_field("attrs", 1u, {|| deserialize_2(s) }),
+                    decl:
+                        s.read_rec_field("decl", 2u, {|| deserialize_38(s) }),
+                    tps:
+                        s.read_rec_field("tps", 3u, {|| deserialize_131(s) }),
+                    span:
+                        s.read_rec_field("span", 4u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*[syntax::ast::ty_method]*/
+fn deserialize_155<S: std::serialization::deserializer>(s: S) ->
+   [syntax::ast::ty_method] {
+    s.read_vec(
+
+               /*syntax::ast::ty_method*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_156(s) })
+                                })
+               })
+}
+/*core::option::t<@syntax::ast::ty>*/
+fn deserialize_157<S: std::serialization::deserializer>(s: S) ->
+   core::option::t<@syntax::ast::ty> {
+    s.read_enum("core::option::t",
+
+
+                /*@syntax::ast::ty*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u { core::option::none }
+                                              1u {
+                                                core::option::some(s.read_enum_variant_arg(0u,
+                                                                                           {||
+                                                                                               deserialize_29(s)
+                                                                                           }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::method*/
+fn deserialize_160<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::method {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ident*/
+
+               /*[syntax::ast::attribute]*/
+
+               /*[syntax::ast::ty_param]*/
+
+               /*syntax::ast::fn_decl*/
+
+               /*syntax::ast::blk*/
+
+               /*syntax::ast::node_id*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {ident:
+                        s.read_rec_field("ident", 0u, {|| deserialize_1(s) }),
+                    attrs:
+                        s.read_rec_field("attrs", 1u, {|| deserialize_2(s) }),
+                    tps:
+                        s.read_rec_field("tps", 2u, {|| deserialize_131(s) }),
+                    decl:
+                        s.read_rec_field("decl", 3u, {|| deserialize_38(s) }),
+                    body:
+                        s.read_rec_field("body", 4u, {|| deserialize_81(s) }),
+                    id: s.read_rec_field("id", 5u, {|| deserialize_27(s) }),
+                    span:
+                        s.read_rec_field("span", 6u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+/*@syntax::ast::method*/
+fn deserialize_159<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::method {
+
+    s.read_box(/*syntax::ast::method*/{|| @deserialize_160(s) })
+
+}
+/*[@syntax::ast::method]*/
+fn deserialize_158<S: std::serialization::deserializer>(s: S) ->
+   [@syntax::ast::method] {
+    s.read_vec(
+
+               /*@syntax::ast::method*/
+               {|len|
+                   vec::init_fn(len,
+                                {|i|
+                                    s.read_vec_elt(i,
+                                                   {|| deserialize_159(s) })
+                                })
+               })
+}
+/*syntax::ast::item_*/
+fn deserialize_28<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::item_ {
+    s.read_enum("syntax::ast::item_",
+                /*@syntax::ast::ty*//*@syntax::ast::expr*/
+
+                /*syntax::ast::fn_decl*//*[syntax::ast::ty_param]*/
+                /*syntax::ast::blk*/
+
+                /*syntax::ast::_mod*/
+
+                /*syntax::ast::native_mod*/
+
+                /*@syntax::ast::ty*//*[syntax::ast::ty_param]*/
+
+                /*[syntax::ast::variant]*//*[syntax::ast::ty_param]*/
+
+                /*syntax::ast::fn_decl*//*[syntax::ast::ty_param]*/
+                /*syntax::ast::blk*//*syntax::ast::node_id*/
+                /*syntax::ast::node_id*/
+
+                /*[syntax::ast::ty_param]*//*[@syntax::ast::class_item]*/
+                /*syntax::ast::node_id*//*syntax::ast::fn_decl*/
+                /*syntax::ast::blk*/
+
+                /*[syntax::ast::ty_param]*//*[syntax::ast::ty_method]*/
+
+                /*[syntax::ast::ty_param]*/
+                /*core::option::t<@syntax::ast::ty>*//*@syntax::ast::ty*/
+                /*[@syntax::ast::method]*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::item_const(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_29(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(1u,
+                                                                                                {||
+                                                                                                    deserialize_70(s)
+                                                                                                }))
+                                              }
+                                              1u {
+                                                syntax::ast::item_fn(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_38(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(1u,
+                                                                                             {||
+                                                                                                 deserialize_131(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(2u,
+                                                                                             {||
+                                                                                                 deserialize_81(s)
+                                                                                             }))
+                                              }
+                                              2u {
+                                                syntax::ast::item_mod(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_136(s)
+                                                                                              }))
+                                              }
+                                              3u {
+                                                syntax::ast::item_native_mod(s.read_enum_variant_arg(0u,
+                                                                                                     {||
+                                                                                                         deserialize_138(s)
+                                                                                                     }))
+                                              }
+                                              4u {
+                                                syntax::ast::item_ty(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_29(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(1u,
+                                                                                             {||
+                                                                                                 deserialize_131(s)
+                                                                                             }))
+                                              }
+                                              5u {
+                                                syntax::ast::item_enum(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_143(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_131(s)
+                                                                                               }))
+                                              }
+                                              6u {
+                                                syntax::ast::item_res(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_38(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(1u,
+                                                                                              {||
+                                                                                                  deserialize_131(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(2u,
+                                                                                              {||
+                                                                                                  deserialize_81(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(3u,
+                                                                                              {||
+                                                                                                  deserialize_27(s)
+                                                                                              }),
+                                                                      s.read_enum_variant_arg(4u,
+                                                                                              {||
+                                                                                                  deserialize_27(s)
+                                                                                              }))
+                                              }
+                                              7u {
+                                                syntax::ast::item_class(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_131(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(1u,
+                                                                                                {||
+                                                                                                    deserialize_148(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(2u,
+                                                                                                {||
+                                                                                                    deserialize_27(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(3u,
+                                                                                                {||
+                                                                                                    deserialize_38(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(4u,
+                                                                                                {||
+                                                                                                    deserialize_81(s)
+                                                                                                }))
+                                              }
+                                              8u {
+                                                syntax::ast::item_iface(s.read_enum_variant_arg(0u,
+                                                                                                {||
+                                                                                                    deserialize_131(s)
+                                                                                                }),
+                                                                        s.read_enum_variant_arg(1u,
+                                                                                                {||
+                                                                                                    deserialize_155(s)
+                                                                                                }))
+                                              }
+                                              9u {
+                                                syntax::ast::item_impl(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_131(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_157(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(2u,
+                                                                                               {||
+                                                                                                   deserialize_29(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(3u,
+                                                                                               {||
+                                                                                                   deserialize_158(s)
+                                                                                               }))
+                                              }
+                                            }
+                                        })
+                })
+}
+/*syntax::ast::item*/
+fn deserialize_0<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::item {
+
+    s.read_rec(
+
+
+               /*syntax::ast::ident*/
+
+               /*[syntax::ast::attribute]*/
+
+               /*syntax::ast::node_id*/
+
+               /*syntax::ast::item_*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {ident:
+                        s.read_rec_field("ident", 0u, {|| deserialize_1(s) }),
+                    attrs:
+                        s.read_rec_field("attrs", 1u, {|| deserialize_2(s) }),
+                    id: s.read_rec_field("id", 2u, {|| deserialize_27(s) }),
+                    node:
+                        s.read_rec_field("node", 3u, {|| deserialize_28(s) }),
+                    span:
+                        s.read_rec_field("span", 4u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+fn deserialize_syntax_ast_item<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::item {
+    deserialize_0(s)
+}
+/*syntax::ast::crate_num*/
+fn serialize_163<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        syntax::ast::crate_num) {
+    s.emit_int(v);
+}
+/*syntax::ast::def_id*/
+fn serialize_162<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::def_id) {
+
+    s.emit_rec(/*syntax::ast::crate_num*//*syntax::ast::node_id*/
+               {||
+                   {
+                       s.emit_rec_field("crate", 0u,
+                                        {|| serialize_163(s, v.crate) });
+                       s.emit_rec_field("node", 1u,
+                                        {|| serialize_27(s, v.node) })
+                   }
+               });
+}
+/*syntax::ast::prim_ty*/
+fn serialize_164<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::prim_ty) {
+
+    s.emit_enum("syntax::ast::prim_ty",
+                /*syntax::ast::int_ty*/
+                /*syntax::ast::uint_ty*/
+                /*syntax::ast::float_ty*/
+
+                {||
+                    alt v {
+                      syntax::ast::ty_int(v0) {
+                        s.emit_enum_variant("syntax::ast::ty_int", 0u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_14(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_uint(v0) {
+                        s.emit_enum_variant("syntax::ast::ty_uint", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_16(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_float(v0) {
+                        s.emit_enum_variant("syntax::ast::ty_float", 2u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_17(s,
+                                                                                             v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::ty_str {
+                        s.emit_enum_variant("syntax::ast::ty_str", 3u, 0u,
+                                            {|| })
+                      }
+                      syntax::ast::ty_bool {
+                        s.emit_enum_variant("syntax::ast::ty_bool", 4u, 0u,
+                                            {|| })
+                      }
+                    }
+                });
+}
+/*@syntax::ast::def*/
+fn serialize_165<S: std::serialization::serializer>(s: S,
+                                                    v: @syntax::ast::def) {
+
+    s.emit_box(/*syntax::ast::def*/{|| serialize_161(s, *v) });
+}
+/*syntax::ast::def*/
+fn serialize_161<S: std::serialization::serializer>(s: S,
+                                                    v: syntax::ast::def) {
+
+    s.emit_enum("syntax::ast::def",
+                /*syntax::ast::def_id*//*syntax::ast::purity*/
+                /*syntax::ast::def_id*/
+                /*syntax::ast::def_id*/
+                /*syntax::ast::def_id*/
+                /*syntax::ast::def_id*/
+                /*syntax::ast::def_id*/
+                /*syntax::ast::mode<syntax::ast::rmode>*/
+                /*syntax::ast::def_id*/
+                /*syntax::ast::def_id*//*syntax::ast::def_id*/
+                /*syntax::ast::def_id*/
+                /*syntax::ast::prim_ty*/
+                /*syntax::ast::def_id*//*uint*/
+                /*syntax::ast::def_id*/
+                /*syntax::ast::def_id*/
+                /*syntax::ast::def_id*//*@syntax::ast::def*/
+                /*syntax::ast::node_id*/
+                /*syntax::ast::def_id*/
+                /*syntax::ast::def_id*//*syntax::ast::def_id*/
+                /*syntax::ast::def_id*//*syntax::ast::def_id*/
+                {||
+                    alt v {
+                      syntax::ast::def_fn(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::def_fn", 0u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_43(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_self(v0) {
+                        s.emit_enum_variant("syntax::ast::def_self", 1u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_mod(v0) {
+                        s.emit_enum_variant("syntax::ast::def_mod", 2u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_native_mod(v0) {
+                        s.emit_enum_variant("syntax::ast::def_native_mod", 3u,
+                                            1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_const(v0) {
+                        s.emit_enum_variant("syntax::ast::def_const", 4u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_arg(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::def_arg", 5u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_41(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_local(v0) {
+                        s.emit_enum_variant("syntax::ast::def_local", 6u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_variant(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::def_variant", 7u,
+                                            2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_ty(v0) {
+                        s.emit_enum_variant("syntax::ast::def_ty", 8u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_prim_ty(v0) {
+                        s.emit_enum_variant("syntax::ast::def_prim_ty", 9u,
+                                            1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_164(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_ty_param(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::def_ty_param", 10u,
+                                            2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_20(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_binding(v0) {
+                        s.emit_enum_variant("syntax::ast::def_binding", 11u,
+                                            1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_use(v0) {
+                        s.emit_enum_variant("syntax::ast::def_use", 12u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_upvar(v0, v1, v2) {
+                        s.emit_enum_variant("syntax::ast::def_upvar", 13u, 3u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_165(s,
+                                                                                              v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_27(s,
+                                                                                             v2)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_class(v0) {
+                        s.emit_enum_variant("syntax::ast::def_class", 14u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_class_field(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::def_class_field",
+                                            15u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      syntax::ast::def_class_method(v0, v1) {
+                        s.emit_enum_variant("syntax::ast::def_class_method",
+                                            16u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+fn serialize_syntax_ast_def<S: std::serialization::serializer>(s: S,
+                                                               v:
+                                                                   syntax::ast::def) {
+    serialize_161(s, v);
+}
+/*syntax::ast::crate_num*/
+fn deserialize_163<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::crate_num {
+    s.read_int()
+}
+/*syntax::ast::def_id*/
+fn deserialize_162<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::def_id {
+
+    s.read_rec(
+
+
+               /*syntax::ast::crate_num*/
+
+               /*syntax::ast::node_id*/
+
+               {||
+                   {crate:
+                        s.read_rec_field("crate", 0u,
+                                         {|| deserialize_163(s) }),
+                    node:
+                        s.read_rec_field("node", 1u,
+                                         {|| deserialize_27(s) }),}
+               })
+
+}
+/*syntax::ast::prim_ty*/
+fn deserialize_164<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::prim_ty {
+    s.read_enum("syntax::ast::prim_ty",
+                /*syntax::ast::int_ty*/
+
+                /*syntax::ast::uint_ty*/
+
+                /*syntax::ast::float_ty*/
+
+
+
+
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::ty_int(s.read_enum_variant_arg(0u,
+                                                                                            {||
+                                                                                                deserialize_14(s)
+                                                                                            }))
+                                              }
+                                              1u {
+                                                syntax::ast::ty_uint(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_16(s)
+                                                                                             }))
+                                              }
+                                              2u {
+                                                syntax::ast::ty_float(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_17(s)
+                                                                                              }))
+                                              }
+                                              3u { syntax::ast::ty_str }
+                                              4u { syntax::ast::ty_bool }
+                                            }
+                                        })
+                })
+}
+/*@syntax::ast::def*/
+fn deserialize_165<S: std::serialization::deserializer>(s: S) ->
+   @syntax::ast::def {
+
+    s.read_box(/*syntax::ast::def*/{|| @deserialize_161(s) })
+
+}
+/*syntax::ast::def*/
+fn deserialize_161<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::def {
+    s.read_enum("syntax::ast::def",
+                /*syntax::ast::def_id*//*syntax::ast::purity*/
+
+                /*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*/
+                /*syntax::ast::mode<syntax::ast::rmode>*/
+
+                /*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*//*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*/
+
+                /*syntax::ast::prim_ty*/
+
+                /*syntax::ast::def_id*//*uint*/
+
+                /*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*//*@syntax::ast::def*/
+                /*syntax::ast::node_id*/
+
+                /*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*//*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*//*syntax::ast::def_id*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                syntax::ast::def_fn(s.read_enum_variant_arg(0u,
+                                                                                            {||
+                                                                                                deserialize_162(s)
+                                                                                            }),
+                                                                    s.read_enum_variant_arg(1u,
+                                                                                            {||
+                                                                                                deserialize_43(s)
+                                                                                            }))
+                                              }
+                                              1u {
+                                                syntax::ast::def_self(s.read_enum_variant_arg(0u,
+                                                                                              {||
+                                                                                                  deserialize_162(s)
+                                                                                              }))
+                                              }
+                                              2u {
+                                                syntax::ast::def_mod(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_162(s)
+                                                                                             }))
+                                              }
+                                              3u {
+                                                syntax::ast::def_native_mod(s.read_enum_variant_arg(0u,
+                                                                                                    {||
+                                                                                                        deserialize_162(s)
+                                                                                                    }))
+                                              }
+                                              4u {
+                                                syntax::ast::def_const(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_162(s)
+                                                                                               }))
+                                              }
+                                              5u {
+                                                syntax::ast::def_arg(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_162(s)
+                                                                                             }),
+                                                                     s.read_enum_variant_arg(1u,
+                                                                                             {||
+                                                                                                 deserialize_41(s)
+                                                                                             }))
+                                              }
+                                              6u {
+                                                syntax::ast::def_local(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_162(s)
+                                                                                               }))
+                                              }
+                                              7u {
+                                                syntax::ast::def_variant(s.read_enum_variant_arg(0u,
+                                                                                                 {||
+                                                                                                     deserialize_162(s)
+                                                                                                 }),
+                                                                         s.read_enum_variant_arg(1u,
+                                                                                                 {||
+                                                                                                     deserialize_162(s)
+                                                                                                 }))
+                                              }
+                                              8u {
+                                                syntax::ast::def_ty(s.read_enum_variant_arg(0u,
+                                                                                            {||
+                                                                                                deserialize_162(s)
+                                                                                            }))
+                                              }
+                                              9u {
+                                                syntax::ast::def_prim_ty(s.read_enum_variant_arg(0u,
+                                                                                                 {||
+                                                                                                     deserialize_164(s)
+                                                                                                 }))
+                                              }
+                                              10u {
+                                                syntax::ast::def_ty_param(s.read_enum_variant_arg(0u,
+                                                                                                  {||
+                                                                                                      deserialize_162(s)
+                                                                                                  }),
+                                                                          s.read_enum_variant_arg(1u,
+                                                                                                  {||
+                                                                                                      deserialize_20(s)
+                                                                                                  }))
+                                              }
+                                              11u {
+                                                syntax::ast::def_binding(s.read_enum_variant_arg(0u,
+                                                                                                 {||
+                                                                                                     deserialize_162(s)
+                                                                                                 }))
+                                              }
+                                              12u {
+                                                syntax::ast::def_use(s.read_enum_variant_arg(0u,
+                                                                                             {||
+                                                                                                 deserialize_162(s)
+                                                                                             }))
+                                              }
+                                              13u {
+                                                syntax::ast::def_upvar(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_162(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(1u,
+                                                                                               {||
+                                                                                                   deserialize_165(s)
+                                                                                               }),
+                                                                       s.read_enum_variant_arg(2u,
+                                                                                               {||
+                                                                                                   deserialize_27(s)
+                                                                                               }))
+                                              }
+                                              14u {
+                                                syntax::ast::def_class(s.read_enum_variant_arg(0u,
+                                                                                               {||
+                                                                                                   deserialize_162(s)
+                                                                                               }))
+                                              }
+                                              15u {
+                                                syntax::ast::def_class_field(s.read_enum_variant_arg(0u,
+                                                                                                     {||
+                                                                                                         deserialize_162(s)
+                                                                                                     }),
+                                                                             s.read_enum_variant_arg(1u,
+                                                                                                     {||
+                                                                                                         deserialize_162(s)
+                                                                                                     }))
+                                              }
+                                              16u {
+                                                syntax::ast::def_class_method(s.read_enum_variant_arg(0u,
+                                                                                                      {||
+                                                                                                          deserialize_162(s)
+                                                                                                      }),
+                                                                              s.read_enum_variant_arg(1u,
+                                                                                                      {||
+                                                                                                          deserialize_162(s)
+                                                                                                      }))
+                                              }
+                                            }
+                                        })
+                })
+}
+fn deserialize_syntax_ast_def<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::def {
+    deserialize_161(s)
+}
+/*middle::typeck::method_origin*/
+fn serialize_166<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        middle::typeck::method_origin) {
+    s.emit_enum("middle::typeck::method_origin",
+                /*syntax::ast::def_id*/
+                /*syntax::ast::def_id*//*uint*//*uint*//*uint*/
+                /*syntax::ast::def_id*//*uint*/
+                {||
+                    alt v {
+                      middle::typeck::method_static(v0) {
+                        s.emit_enum_variant("middle::typeck::method_static",
+                                            0u, 1u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      middle::typeck::method_param(v0, v1, v2, v3) {
+                        s.emit_enum_variant("middle::typeck::method_param",
+                                            1u, 4u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_20(s,
+                                                                                             v1)
+                                                                            });
+                                                    s.emit_enum_variant_arg(2u,
+                                                                            {||
+                                                                                serialize_20(s,
+                                                                                             v2)
+                                                                            });
+                                                    s.emit_enum_variant_arg(3u,
+                                                                            {||
+                                                                                serialize_20(s,
+                                                                                             v3)
+                                                                            })
+                                                }
+                                            })
+                      }
+                      middle::typeck::method_iface(v0, v1) {
+                        s.emit_enum_variant("middle::typeck::method_iface",
+                                            2u, 2u,
+                                            {||
+                                                {
+                                                    s.emit_enum_variant_arg(0u,
+                                                                            {||
+                                                                                serialize_162(s,
+                                                                                              v0)
+                                                                            });
+                                                    s.emit_enum_variant_arg(1u,
+                                                                            {||
+                                                                                serialize_20(s,
+                                                                                             v1)
+                                                                            })
+                                                }
+                                            })
+                      }
+                    }
+                });
+}
+fn serialize_middle_typeck_method_origin<S: std::serialization::serializer>(s:
+                                                                                S,
+                                                                            v:
+                                                                                middle::typeck::method_origin) {
+    serialize_166(s, v);
+}
+/*middle::typeck::method_origin*/
+fn deserialize_166<S: std::serialization::deserializer>(s: S) ->
+   middle::typeck::method_origin {
+    s.read_enum("middle::typeck::method_origin",
+                /*syntax::ast::def_id*/
+
+                /*syntax::ast::def_id*//*uint*//*uint*//*uint*/
+
+                /*syntax::ast::def_id*//*uint*/
+                {||
+                    s.read_enum_variant({|v_id|
+                                            alt check v_id {
+                                              0u {
+                                                middle::typeck::method_static(s.read_enum_variant_arg(0u,
+                                                                                                      {||
+                                                                                                          deserialize_162(s)
+                                                                                                      }))
+                                              }
+                                              1u {
+                                                middle::typeck::method_param(s.read_enum_variant_arg(0u,
+                                                                                                     {||
+                                                                                                         deserialize_162(s)
+                                                                                                     }),
+                                                                             s.read_enum_variant_arg(1u,
+                                                                                                     {||
+                                                                                                         deserialize_20(s)
+                                                                                                     }),
+                                                                             s.read_enum_variant_arg(2u,
+                                                                                                     {||
+                                                                                                         deserialize_20(s)
+                                                                                                     }),
+                                                                             s.read_enum_variant_arg(3u,
+                                                                                                     {||
+                                                                                                         deserialize_20(s)
+                                                                                                     }))
+                                              }
+                                              2u {
+                                                middle::typeck::method_iface(s.read_enum_variant_arg(0u,
+                                                                                                     {||
+                                                                                                         deserialize_162(s)
+                                                                                                     }),
+                                                                             s.read_enum_variant_arg(1u,
+                                                                                                     {||
+                                                                                                         deserialize_20(s)
+                                                                                                     }))
+                                              }
+                                            }
+                                        })
+                })
+}
+fn deserialize_middle_typeck_method_origin<S: std::serialization::deserializer>(s:
+                                                                                    S)
+   -> middle::typeck::method_origin {
+    deserialize_166(s)
+}
+/*middle::freevars::freevar_entry*/
+fn serialize_167<S: std::serialization::serializer>(s: S,
+                                                    v:
+                                                        middle::freevars::freevar_entry) {
+    s.emit_rec(/*syntax::ast::def*//*syntax::codemap::span*/
+               {||
+                   {
+                       s.emit_rec_field("def", 0u,
+                                        {|| serialize_161(s, v.def) });
+                       s.emit_rec_field("span", 1u,
+                                        {|| serialize_19(s, v.span) })
+                   }
+               });
+}
+fn serialize_middle_freevars_freevar_entry<S: std::serialization::serializer>(s:
+                                                                                  S,
+                                                                              v:
+                                                                                  middle::freevars::freevar_entry) {
+    serialize_167(s, v);
+}
+/*middle::freevars::freevar_entry*/
+fn deserialize_167<S: std::serialization::deserializer>(s: S) ->
+   middle::freevars::freevar_entry {
+
+    s.read_rec(
+
+
+               /*syntax::ast::def*/
+
+               /*syntax::codemap::span*/
+
+               {||
+                   {def:
+                        s.read_rec_field("def", 0u, {|| deserialize_161(s) }),
+                    span:
+                        s.read_rec_field("span", 1u,
+                                         {|| deserialize_19(s) }),}
+               })
+
+}
+fn deserialize_middle_freevars_freevar_entry<S: std::serialization::deserializer>(s:
+                                                                                      S)
+   -> middle::freevars::freevar_entry {
+    deserialize_167(s)
+}
+fn serialize_syntax_ast_def_id<S: std::serialization::serializer>(s: S,
+                                                                  v:
+                                                                      syntax::ast::def_id) {
+    serialize_162(s, v);
+}
+fn deserialize_syntax_ast_def_id<S: std::serialization::deserializer>(s: S) ->
+   syntax::ast::def_id {
+    deserialize_162(s)
+}
diff --git a/src/comp/metadata/common.rs b/src/comp/metadata/common.rs
index 32358794212..4ccb3405560 100644
--- a/src/comp/metadata/common.rs
+++ b/src/comp/metadata/common.rs
@@ -76,6 +76,30 @@ const tag_path_len: uint = 0x41u;
 const tag_path_elt_mod: uint = 0x42u;
 const tag_path_elt_name: uint = 0x43u;
 
+// used to encode crate_ctxt side tables
+enum astencode_tag { // Reserves 0x50 -- 0x6f
+    tag_ast = 0x50,
+
+    tag_tree = 0x51,
+
+    tag_id_range = 0x52,
+
+    tag_table = 0x53,
+    tag_table_id = 0x54,
+    tag_table_val = 0x55,
+    tag_table_def = 0x56,
+    tag_table_node_type = 0x57,
+    tag_table_node_type_subst = 0x58,
+    tag_table_freevars = 0x59,
+    tag_table_tcache,
+    tag_table_param_bounds,
+    tag_table_inferred_modes,
+    tag_table_mutbl,
+    tag_table_copy,
+    tag_table_last_use,
+    tag_table_method_map,
+    tag_table_dict_map
+}
 
 // djb's cdb hashes.
 fn hash_node_id(&&node_id: int) -> uint { ret 177573u ^ (node_id as uint); }
diff --git a/src/comp/metadata/csearch.rs b/src/comp/metadata/csearch.rs
index ab760815227..646ba5ea751 100644
--- a/src/comp/metadata/csearch.rs
+++ b/src/comp/metadata/csearch.rs
@@ -5,6 +5,7 @@ import syntax::ast_util;
 import middle::{ty, ast_map};
 import option::{some, none};
 import driver::session;
+import middle::trans::common::maps;
 
 export get_symbol;
 export get_type_param_count;
@@ -16,6 +17,7 @@ export get_iface_methods;
 export get_type;
 export get_impl_iface;
 export get_item_path;
+export maybe_get_item_ast;
 
 fn get_symbol(cstore: cstore::cstore, def: ast::def_id) -> str {
     let cdata = cstore::get_crate_data(cstore, def.crate).data;
@@ -73,6 +75,16 @@ fn get_item_path(tcx: ty::ctxt, def: ast::def_id) -> ast_map::path {
     [ast_map::path_mod(cdata.name)] + path
 }
 
+// Finds the AST for this item in the crate metadata, if any.  If the item was
+// not marked for inlining, then the AST will not be present and hence none
+// will be returned.
+fn maybe_get_item_ast(tcx: ty::ctxt, maps: maps, def: ast::def_id)
+    -> option<@ast::item> {
+    let cstore = tcx.sess.cstore;
+    let cdata = cstore::get_crate_data(cstore, def.crate);
+    decoder::maybe_get_item_ast(cdata, tcx, maps, def.node)
+}
+
 fn get_enum_variants(tcx: ty::ctxt, def: ast::def_id) -> [ty::variant_info] {
     let cstore = tcx.sess.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs
index 06b0acdf4a1..6b741189c48 100644
--- a/src/comp/metadata/decoder.rs
+++ b/src/comp/metadata/decoder.rs
@@ -11,6 +11,7 @@ import common::*;
 import tydecode::{parse_ty_data, parse_def_id, parse_bounds_data};
 import syntax::print::pprust;
 import cmd=cstore::crate_metadata;
+import middle::trans::common::maps;
 
 export get_symbol;
 export get_enum_variants;
@@ -30,6 +31,10 @@ export get_impls_for_mod;
 export get_iface_methods;
 export get_crate_module_paths;
 export get_item_path;
+export maybe_get_item_ast;
+
+// Used internally by astencode:
+export translate_def_id;
 
 // A function that takes a def_id relative to the crate being searched and
 // returns a def_id relative to the compilation environment, i.e. if we hit a
@@ -42,14 +47,14 @@ fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]) -> bool, hash: uint) ->
     let index = ebml::get_doc(d, tag_index);
     let table = ebml::get_doc(index, tag_index_table);
     let hash_pos = table.start + hash % 256u * 4u;
-    let pos = ebml::be_u64_from_bytes(d.data, hash_pos, 4u) as uint;
+    let pos = io::u64_from_be_bytes(*d.data, hash_pos, 4u) as uint;
     let {tag:_, doc:bucket} = ebml::doc_at(d.data, pos);
     // Awkward logic because we can't ret from foreach yet
 
     let result: [ebml::doc] = [];
     let belt = tag_index_buckets_bucket_elt;
     ebml::tagged_docs(bucket, belt) {|elt|
-        let pos = ebml::be_u64_from_bytes(elt.data, elt.start, 4u) as uint;
+        let pos = io::u64_from_be_bytes(*elt.data, elt.start, 4u) as uint;
         if eq_fn(vec::slice::<u8>(*elt.data, elt.start + 4u, elt.end)) {
             result += [ebml::doc_at(d.data, pos).doc];
         }
@@ -59,7 +64,7 @@ fn lookup_hash(d: ebml::doc, eq_fn: fn@([u8]) -> bool, hash: uint) ->
 
 fn maybe_find_item(item_id: int, items: ebml::doc) -> option<ebml::doc> {
     fn eq_item(bytes: [u8], item_id: int) -> bool {
-        ret ebml::be_u64_from_bytes(@bytes, 0u, 4u) as int == item_id;
+        ret io::u64_from_be_bytes(bytes, 0u, 4u) as int == item_id;
     }
     let eqer = bind eq_item(_, item_id);
     let found = lookup_hash(items, eqer, hash_node_id(item_id));
@@ -178,17 +183,17 @@ fn item_path(item_doc: ebml::doc) -> ast_map::path {
     let path_doc = ebml::get_doc(item_doc, tag_path);
 
     let len_doc = ebml::get_doc(path_doc, tag_path_len);
-    let len = ebml::doc_as_vuint(len_doc);
+    let len = ebml::doc_as_u32(len_doc) as uint;
 
     let result = [];
     vec::reserve(result, len);
 
     ebml::docs(path_doc) {|tag, elt_doc|
         if tag == tag_path_elt_mod {
-            let str = ebml::doc_str(elt_doc);
+            let str = ebml::doc_as_str(elt_doc);
             result += [ast_map::path_mod(str)];
         } else if tag == tag_path_elt_name {
-            let str = ebml::doc_str(elt_doc);
+            let str = ebml::doc_as_str(elt_doc);
             result += [ast_map::path_name(str)];
         } else {
             // ignore tag_path_len element
@@ -258,6 +263,13 @@ fn get_item_path(cdata: cmd, id: ast::node_id) -> ast_map::path {
     item_path(lookup_item(id, cdata.data))
 }
 
+fn maybe_get_item_ast(cdata: cmd, tcx: ty::ctxt, maps: maps,
+                      id: ast::node_id) -> option<@ast::item> {
+    let item_doc = lookup_item(id, cdata.data);
+    let path = vec::init(item_path(item_doc));
+    astencode::decode_inlined_item(cdata, tcx, maps, path, item_doc)
+}
+
 fn get_enum_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
     -> [ty::variant_info] {
     let data = cdata.data;
@@ -353,7 +365,7 @@ fn family_names_type(fam_ch: char) -> bool {
 
 fn read_path(d: ebml::doc) -> {path: str, pos: uint} {
     let desc = ebml::doc_data(d);
-    let pos = ebml::be_u64_from_bytes(@desc, 0u, 4u) as uint;
+    let pos = io::u64_from_be_bytes(desc, 0u, 4u) as uint;
     let pathbytes = vec::slice::<u8>(desc, 4u, vec::len::<u8>(desc));
     let path = str::from_bytes(pathbytes);
     ret {path: path, pos: pos};
diff --git a/src/comp/metadata/encoder.rs b/src/comp/metadata/encoder.rs
index 9eb0a34dbcc..348c28784a2 100644
--- a/src/comp/metadata/encoder.rs
+++ b/src/comp/metadata/encoder.rs
@@ -2,8 +2,9 @@
 
 import std::{io, ebml, map, list};
 import io::writer_util;
-import ebml::writer_util;
+import ebml::writer;
 import syntax::ast::*;
+import syntax::print::pprust;
 import syntax::ast_util;
 import syntax::ast_util::local_def;
 import common::*;
@@ -13,25 +14,40 @@ import middle::ty::node_id_to_type;
 import middle::ast_map;
 import front::attr;
 import driver::session::session;
+import std::serialization::serializer;
 
 export encode_metadata;
 export encoded_ty;
 
+// used by astencode:
+export def_to_str;
+export encode_ctxt;
+export write_type;
+export encode_def_id;
+
 type abbrev_map = map::hashmap<ty::t, tyencode::ty_abbrev>;
 
 type encode_ctxt = {ccx: crate_ctxt, type_abbrevs: abbrev_map};
 
+fn should_inline(path: ast_map::path, item: @item) -> bool {
+    if item.ident == "iter" { // XXX
+        #debug["should_inline(%s::%s)? attrs=%s result=%b",
+               ast_map::path_to_str(path),
+               item.ident,
+               str::connect(vec::map(item.attrs, pprust::attr_to_str), ", "),
+               attr::attrs_contains_name(item.attrs, "inline")];
+    }
+
+    attr::attrs_contains_name(item.attrs, "inline")
+}
+
 // Path table encoding
 fn encode_name(ebml_w: ebml::writer, name: str) {
-    ebml_w.wr_tag(tag_paths_data_name) {||
-        ebml_w.wr_str(name);
-    }
+    ebml_w.wr_tagged_str(tag_paths_data_name, name);
 }
 
 fn encode_def_id(ebml_w: ebml::writer, id: def_id) {
-    ebml_w.wr_tag(tag_def_id) {||
-        ebml_w.wr_str(def_to_str(id));
-    }
+    ebml_w.wr_tagged_str(tag_def_id, def_to_str(id));
 }
 
 fn encode_named_def_id(ebml_w: ebml::writer, name: str, id: def_id) {
@@ -85,57 +101,57 @@ fn encode_module_item_paths(ebml_w: ebml::writer, module: _mod, path: [str],
           }
           item_mod(_mod) {
             add_to_index(ebml_w, path, index, it.ident);
-            ebml::start_tag(ebml_w, tag_paths_data_mod);
+            ebml_w.start_tag(tag_paths_data_mod);
             encode_name(ebml_w, it.ident);
             encode_def_id(ebml_w, local_def(it.id));
             encode_module_item_paths(ebml_w, _mod, path + [it.ident], index);
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
           }
           item_native_mod(nmod) {
             add_to_index(ebml_w, path, index, it.ident);
-            ebml::start_tag(ebml_w, tag_paths_data_mod);
+            ebml_w.start_tag(tag_paths_data_mod);
             encode_name(ebml_w, it.ident);
             encode_def_id(ebml_w, local_def(it.id));
             encode_native_module_item_paths(ebml_w, nmod, path + [it.ident],
                                             index);
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
           }
           item_ty(_, tps) {
             add_to_index(ebml_w, path, index, it.ident);
-            ebml::start_tag(ebml_w, tag_paths_data_item);
+            ebml_w.start_tag(tag_paths_data_item);
             encode_name(ebml_w, it.ident);
             encode_def_id(ebml_w, local_def(it.id));
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
           }
           item_res(_, tps, _, _, ctor_id) {
             add_to_index(ebml_w, path, index, it.ident);
-            ebml::start_tag(ebml_w, tag_paths_data_item);
+            ebml_w.start_tag(tag_paths_data_item);
             encode_name(ebml_w, it.ident);
             encode_def_id(ebml_w, local_def(ctor_id));
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
             add_to_index(ebml_w, path, index, it.ident);
-            ebml::start_tag(ebml_w, tag_paths_data_item);
+            ebml_w.start_tag(tag_paths_data_item);
             encode_name(ebml_w, it.ident);
             encode_def_id(ebml_w, local_def(it.id));
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
           }
           item_class(_,_,_,_,_) {
               fail "encode: implement item_class";
           }
           item_enum(variants, tps) {
             add_to_index(ebml_w, path, index, it.ident);
-            ebml::start_tag(ebml_w, tag_paths_data_item);
+            ebml_w.start_tag(tag_paths_data_item);
             encode_name(ebml_w, it.ident);
             encode_def_id(ebml_w, local_def(it.id));
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
             encode_enum_variant_paths(ebml_w, variants, path, index);
           }
           item_iface(_, _) {
             add_to_index(ebml_w, path, index, it.ident);
-            ebml::start_tag(ebml_w, tag_paths_data_item);
+            ebml_w.start_tag(tag_paths_data_item);
             encode_name(ebml_w, it.ident);
             encode_def_id(ebml_w, local_def(it.id));
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
           }
           item_impl(_, _, _, _) {}
         }
@@ -146,10 +162,10 @@ fn encode_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt, crate: @crate)
     -> [entry<str>] {
     let index: [entry<str>] = [];
     let path: [str] = [];
-    ebml::start_tag(ebml_w, tag_paths);
+    ebml_w.start_tag(tag_paths);
     encode_module_item_paths(ebml_w, crate.node.module, path, index);
     encode_reexport_paths(ebml_w, ecx, index);
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
     ret index;
 }
 
@@ -158,10 +174,10 @@ fn encode_reexport_paths(ebml_w: ebml::writer,
     ecx.ccx.exp_map.items {|path, defs|
         for def in *defs {
             index += [{val: path, pos: ebml_w.writer.tell()}];
-            ebml::start_tag(ebml_w, tag_paths_data_item);
+            ebml_w.start_tag(tag_paths_data_item);
             encode_name(ebml_w, path);
             encode_def_id(ebml_w, ast_util::def_id_of_def(def));
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
         }
     }
 }
@@ -169,9 +185,9 @@ fn encode_reexport_paths(ebml_w: ebml::writer,
 
 // Item info table encoding
 fn encode_family(ebml_w: ebml::writer, c: char) {
-    ebml::start_tag(ebml_w, tag_items_data_item_family);
+    ebml_w.start_tag(tag_items_data_item_family);
     ebml_w.writer.write([c as u8]);
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn def_to_str(did: def_id) -> str { ret #fmt["%d:%d", did.crate, did.node]; }
@@ -182,17 +198,17 @@ fn encode_type_param_bounds(ebml_w: ebml::writer, ecx: @encode_ctxt,
                         tcx: ecx.ccx.tcx,
                         abbrevs: tyencode::ac_use_abbrevs(ecx.type_abbrevs)};
     for param in params {
-        ebml::start_tag(ebml_w, tag_items_data_item_ty_param_bounds);
+        ebml_w.start_tag(tag_items_data_item_ty_param_bounds);
         let bs = ecx.ccx.tcx.ty_param_bounds.get(param.id);
         tyencode::enc_bounds(ebml_w.writer, ty_str_ctxt, bs);
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
     }
 }
 
 fn encode_variant_id(ebml_w: ebml::writer, vid: def_id) {
-    ebml::start_tag(ebml_w, tag_items_data_item_variant);
+    ebml_w.start_tag(tag_items_data_item_variant);
     ebml_w.writer.write(str::bytes(def_to_str(vid)));
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn write_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
@@ -204,33 +220,33 @@ fn write_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
 }
 
 fn encode_type(ecx: @encode_ctxt, ebml_w: ebml::writer, typ: ty::t) {
-    ebml::start_tag(ebml_w, tag_items_data_item_type);
+    ebml_w.start_tag(tag_items_data_item_type);
     write_type(ecx, ebml_w, typ);
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn encode_symbol(ecx: @encode_ctxt, ebml_w: ebml::writer, id: node_id) {
-    ebml::start_tag(ebml_w, tag_items_data_item_symbol);
+    ebml_w.start_tag(tag_items_data_item_symbol);
     ebml_w.writer.write(str::bytes(ecx.ccx.item_symbols.get(id)));
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn encode_discriminant(ecx: @encode_ctxt, ebml_w: ebml::writer, id: node_id) {
-    ebml::start_tag(ebml_w, tag_items_data_item_symbol);
+    ebml_w.start_tag(tag_items_data_item_symbol);
     ebml_w.writer.write(str::bytes(ecx.ccx.discrim_symbols.get(id)));
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn encode_disr_val(_ecx: @encode_ctxt, ebml_w: ebml::writer, disr_val: int) {
-    ebml::start_tag(ebml_w, tag_disr_val);
+    ebml_w.start_tag(tag_disr_val);
     ebml_w.writer.write(str::bytes(int::to_str(disr_val,10u)));
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn encode_enum_id(ebml_w: ebml::writer, id: def_id) {
-    ebml::start_tag(ebml_w, tag_items_data_item_enum_id);
+    ebml_w.start_tag(tag_items_data_item_enum_id);
     ebml_w.writer.write(str::bytes(def_to_str(id)));
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
@@ -242,7 +258,7 @@ fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
     let vi = ty::enum_variants(ecx.ccx.tcx, {crate: local_crate, node: id});
     for variant: variant in variants {
         index += [{val: variant.node.id, pos: ebml_w.writer.tell()}];
-        ebml::start_tag(ebml_w, tag_items_data_item);
+        ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(variant.node.id));
         encode_family(ebml_w, 'v');
         encode_name(ebml_w, variant.node.name);
@@ -259,7 +275,7 @@ fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
         }
         encode_type_param_bounds(ebml_w, ecx, ty_params);
         encode_path(ebml_w, path, ast_map::path_name(variant.node.name));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
         disr_val += 1;
         i += 1;
     }
@@ -274,15 +290,11 @@ fn encode_path(ebml_w: ebml::writer,
           ast_map::path_name(name) { (tag_path_elt_name, name) }
         };
 
-        ebml_w.wr_tag(tag) {||
-            ebml_w.wr_str(name)
-        }
+        ebml_w.wr_tagged_str(tag, name);
     }
 
     ebml_w.wr_tag(tag_path) {||
-        ebml_w.wr_tag(tag_path_len) {||
-            ebml_w.wr_vuint(vec::len(path) + 1u);
-        }
+        ebml_w.wr_tagged_u32(tag_path_len, (vec::len(path) + 1u) as u32);
         vec::iter(path) {|pe| encode_path_elt(ebml_w, pe); }
         encode_path_elt(ebml_w, name);
     }
@@ -290,17 +302,15 @@ fn encode_path(ebml_w: ebml::writer,
 
 fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod,
                        id: node_id, path: ast_map::path, name: ident) {
-    ebml::start_tag(ebml_w, tag_items_data_item);
+    ebml_w.start_tag(tag_items_data_item);
     encode_def_id(ebml_w, local_def(id));
     encode_family(ebml_w, 'm');
     encode_name(ebml_w, name);
-    alt ecx.ccx.impl_map.get(id) {
+    alt ecx.ccx.maps.impl_map.get(id) {
       list::cons(impls, @list::nil) {
         for i in *impls {
             if ast_util::is_exported(i.ident, md) {
-                ebml::start_tag(ebml_w, tag_mod_impl);
-                ebml_w.writer.write(str::bytes(def_to_str(i.did)));
-                ebml::end_tag(ebml_w);
+                ebml_w.wr_tagged_str(tag_mod_impl, def_to_str(i.did));
             }
         }
       }
@@ -308,7 +318,7 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::writer, md: _mod,
              undocumented invariant"); }
     }
     encode_path(ebml_w, path, ast_map::path_mod(name));
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn purity_fn_family(p: purity) -> char {
@@ -325,47 +335,50 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
     let tcx = ecx.ccx.tcx;
     alt item.node {
       item_const(_, _) {
-        ebml::start_tag(ebml_w, tag_items_data_item);
+        ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'c');
         encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
         encode_symbol(ecx, ebml_w, item.id);
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
       }
       item_fn(decl, tps, _) {
-        ebml::start_tag(ebml_w, tag_items_data_item);
+        ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, purity_fn_family(decl.purity));
         encode_type_param_bounds(ebml_w, ecx, tps);
         encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
         encode_symbol(ecx, ebml_w, item.id);
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        ebml::end_tag(ebml_w);
+        if should_inline(path, item) {
+            astencode::encode_inlined_item(ecx, ebml_w, item);
+        }
+        ebml_w.end_tag();
       }
       item_mod(m) {
         encode_info_for_mod(ecx, ebml_w, m, item.id, path, item.ident);
       }
       item_native_mod(_) {
-        ebml::start_tag(ebml_w, tag_items_data_item);
+        ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'n');
         encode_name(ebml_w, item.ident);
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
       }
       item_ty(_, tps) {
-        ebml::start_tag(ebml_w, tag_items_data_item);
+        ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'y');
         encode_type_param_bounds(ebml_w, ecx, tps);
         encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
         encode_name(ebml_w, item.ident);
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
       }
       item_enum(variants, tps) {
-        ebml::start_tag(ebml_w, tag_items_data_item);
+        ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 't');
         encode_type_param_bounds(ebml_w, ecx, tps);
@@ -375,7 +388,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
             encode_variant_id(ebml_w, local_def(v.node.id));
         }
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
         encode_enum_variant_info(ecx, ebml_w, item.id, variants,
                                  path, index, tps);
       }
@@ -385,7 +398,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
       item_res(_, tps, _, _, ctor_id) {
         let fn_ty = node_id_to_type(tcx, ctor_id);
 
-        ebml::start_tag(ebml_w, tag_items_data_item);
+        ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(ctor_id));
         encode_family(ebml_w, 'y');
         encode_type_param_bounds(ebml_w, ecx, tps);
@@ -393,47 +406,47 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_name(ebml_w, item.ident);
         encode_symbol(ecx, ebml_w, item.id);
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
 
         index += [{val: ctor_id, pos: ebml_w.writer.tell()}];
-        ebml::start_tag(ebml_w, tag_items_data_item);
+        ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(ctor_id));
         encode_family(ebml_w, 'f');
         encode_type_param_bounds(ebml_w, ecx, tps);
         encode_type(ecx, ebml_w, fn_ty);
         encode_symbol(ecx, ebml_w, ctor_id);
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
       }
       item_impl(tps, ifce, _, methods) {
-        ebml::start_tag(ebml_w, tag_items_data_item);
+        ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'i');
         encode_type_param_bounds(ebml_w, ecx, tps);
         encode_type(ecx, ebml_w, node_id_to_type(tcx, item.id));
         encode_name(ebml_w, item.ident);
         for m in methods {
-            ebml::start_tag(ebml_w, tag_item_method);
+            ebml_w.start_tag(tag_item_method);
             ebml_w.writer.write(str::bytes(def_to_str(local_def(m.id))));
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
         }
         alt ifce {
           some(_) {
             encode_symbol(ecx, ebml_w, item.id);
             let i_ty = ty::lookup_item_type(tcx, local_def(item.id)).ty;
-            ebml::start_tag(ebml_w, tag_impl_iface);
+            ebml_w.start_tag(tag_impl_iface);
             write_type(ecx, ebml_w, i_ty);
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
           }
           _ {}
         }
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
 
         let impl_path = path + [ast_map::path_name(item.ident)];
         for m in methods {
             index += [{val: m.id, pos: ebml_w.writer.tell()}];
-            ebml::start_tag(ebml_w, tag_items_data_item);
+            ebml_w.start_tag(tag_items_data_item);
             encode_def_id(ebml_w, local_def(m.id));
             encode_family(ebml_w, purity_fn_family(m.decl.purity));
             encode_type_param_bounds(ebml_w, ecx, tps + m.tps);
@@ -441,11 +454,11 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
             encode_name(ebml_w, m.ident);
             encode_symbol(ecx, ebml_w, m.id);
             encode_path(ebml_w, impl_path, ast_map::path_name(m.ident));
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
         }
       }
       item_iface(tps, ms) {
-        ebml::start_tag(ebml_w, tag_items_data_item);
+        ebml_w.start_tag(tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));
         encode_family(ebml_w, 'I');
         encode_type_param_bounds(ebml_w, ecx, tps);
@@ -453,23 +466,23 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_name(ebml_w, item.ident);
         let i = 0u;
         for mty in *ty::iface_methods(tcx, local_def(item.id)) {
-            ebml::start_tag(ebml_w, tag_item_method);
+            ebml_w.start_tag(tag_item_method);
             encode_name(ebml_w, mty.ident);
             encode_type_param_bounds(ebml_w, ecx, ms[i].tps);
             encode_type(ecx, ebml_w, ty::mk_fn(tcx, mty.fty));
             encode_family(ebml_w, purity_fn_family(mty.purity));
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
             i += 1u;
         }
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
       }
     }
 }
 
 fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
                                nitem: @native_item, path: ast_map::path) {
-    ebml::start_tag(ebml_w, tag_items_data_item);
+    ebml_w.start_tag(tag_items_data_item);
     alt nitem.node {
       native_item_fn(fn_decl, tps) {
         encode_def_id(ebml_w, local_def(nitem.id));
@@ -480,16 +493,16 @@ fn encode_info_for_native_item(ecx: @encode_ctxt, ebml_w: ebml::writer,
         encode_path(ebml_w, path, ast_map::path_name(nitem.ident));
       }
     }
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
                          crate_mod: _mod) -> [entry<int>] {
     let index: [entry<int>] = [];
-    ebml::start_tag(ebml_w, tag_items_data);
+    ebml_w.start_tag(tag_items_data);
     index += [{val: crate_node_id, pos: ebml_w.writer.tell()}];
     encode_info_for_mod(ecx, ebml_w, crate_mod, crate_node_id, [], "");
-    ecx.ccx.ast_map.items {|key, val|
+    ecx.ccx.tcx.items.items {|key, val|
         alt val {
           middle::ast_map::node_item(i, path) {
             index += [{val: key, pos: ebml_w.writer.tell()}];
@@ -502,7 +515,7 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
           _ { }
         }
     };
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
     ret index;
 }
 
@@ -528,25 +541,25 @@ fn create_index<T: copy>(index: [entry<T>], hash_fn: fn@(T) -> uint) ->
 fn encode_index<T>(ebml_w: ebml::writer, buckets: [@[entry<T>]],
                    write_fn: fn(io::writer, T)) {
     let writer = ebml_w.writer;
-    ebml::start_tag(ebml_w, tag_index);
+    ebml_w.start_tag(tag_index);
     let bucket_locs: [uint] = [];
-    ebml::start_tag(ebml_w, tag_index_buckets);
+    ebml_w.start_tag(tag_index_buckets);
     for bucket: @[entry<T>] in buckets {
         bucket_locs += [ebml_w.writer.tell()];
-        ebml::start_tag(ebml_w, tag_index_buckets_bucket);
+        ebml_w.start_tag(tag_index_buckets_bucket);
         for elt: entry<T> in *bucket {
-            ebml::start_tag(ebml_w, tag_index_buckets_bucket_elt);
+            ebml_w.start_tag(tag_index_buckets_bucket_elt);
             writer.write_be_uint(elt.pos, 4u);
             write_fn(writer, elt.val);
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
         }
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
     }
-    ebml::end_tag(ebml_w);
-    ebml::start_tag(ebml_w, tag_index_table);
+    ebml_w.end_tag();
+    ebml_w.start_tag(tag_index_table);
     for pos: uint in bucket_locs { writer.write_be_uint(pos, 4u); }
-    ebml::end_tag(ebml_w);
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
+    ebml_w.end_tag();
 }
 
 fn write_str(writer: io::writer, &&s: str) { writer.write_str(s); }
@@ -558,48 +571,48 @@ fn write_int(writer: io::writer, &&n: int) {
 fn encode_meta_item(ebml_w: ebml::writer, mi: meta_item) {
     alt mi.node {
       meta_word(name) {
-        ebml::start_tag(ebml_w, tag_meta_item_word);
-        ebml::start_tag(ebml_w, tag_meta_item_name);
+        ebml_w.start_tag(tag_meta_item_word);
+        ebml_w.start_tag(tag_meta_item_name);
         ebml_w.writer.write(str::bytes(name));
-        ebml::end_tag(ebml_w);
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
+        ebml_w.end_tag();
       }
       meta_name_value(name, value) {
         alt value.node {
           lit_str(value) {
-            ebml::start_tag(ebml_w, tag_meta_item_name_value);
-            ebml::start_tag(ebml_w, tag_meta_item_name);
+            ebml_w.start_tag(tag_meta_item_name_value);
+            ebml_w.start_tag(tag_meta_item_name);
             ebml_w.writer.write(str::bytes(name));
-            ebml::end_tag(ebml_w);
-            ebml::start_tag(ebml_w, tag_meta_item_value);
+            ebml_w.end_tag();
+            ebml_w.start_tag(tag_meta_item_value);
             ebml_w.writer.write(str::bytes(value));
-            ebml::end_tag(ebml_w);
-            ebml::end_tag(ebml_w);
+            ebml_w.end_tag();
+            ebml_w.end_tag();
           }
           _ {/* FIXME (#611) */ }
         }
       }
       meta_list(name, items) {
-        ebml::start_tag(ebml_w, tag_meta_item_list);
-        ebml::start_tag(ebml_w, tag_meta_item_name);
+        ebml_w.start_tag(tag_meta_item_list);
+        ebml_w.start_tag(tag_meta_item_name);
         ebml_w.writer.write(str::bytes(name));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
         for inner_item: @meta_item in items {
             encode_meta_item(ebml_w, *inner_item);
         }
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
       }
     }
 }
 
 fn encode_attributes(ebml_w: ebml::writer, attrs: [attribute]) {
-    ebml::start_tag(ebml_w, tag_attributes);
+    ebml_w.start_tag(tag_attributes);
     for attr: attribute in attrs {
-        ebml::start_tag(ebml_w, tag_attribute);
+        ebml_w.start_tag(tag_attribute);
         encode_meta_item(ebml_w, attr.node.value);
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
     }
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 // So there's a special crate attribute called 'link' which defines the
@@ -687,19 +700,19 @@ fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) {
     // that they are numbered 1 to n.
     // FIXME: This is not nearly enough to support correct versioning
     // but is enough to get transitive crate dependencies working.
-    ebml::start_tag(ebml_w, tag_crate_deps);
+    ebml_w.start_tag(tag_crate_deps);
     for cname: str in get_ordered_names(cstore) {
-        ebml::start_tag(ebml_w, tag_crate_dep);
+        ebml_w.start_tag(tag_crate_dep);
         ebml_w.writer.write(str::bytes(cname));
-        ebml::end_tag(ebml_w);
+        ebml_w.end_tag();
     }
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn encode_hash(ebml_w: ebml::writer, hash: str) {
-    ebml::start_tag(ebml_w, tag_crate_hash);
+    ebml_w.start_tag(tag_crate_hash);
     ebml_w.writer.write(str::bytes(hash));
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 }
 
 fn encode_metadata(cx: crate_ctxt, crate: @crate) -> [u8] {
@@ -709,7 +722,7 @@ fn encode_metadata(cx: crate_ctxt, crate: @crate) -> [u8] {
 
     let buf = io::mk_mem_buffer();
     let buf_w = io::mem_buffer_writer(buf);
-    let ebml_w = ebml::create_writer(buf_w);
+    let ebml_w = ebml::mk_writer(buf_w);
 
     encode_hash(ebml_w, cx.link_meta.extras_hash);
 
@@ -719,18 +732,18 @@ fn encode_metadata(cx: crate_ctxt, crate: @crate) -> [u8] {
     encode_crate_deps(ebml_w, cx.sess.cstore);
 
     // Encode and index the paths.
-    ebml::start_tag(ebml_w, tag_paths);
+    ebml_w.start_tag(tag_paths);
     let paths_index = encode_item_paths(ebml_w, ecx, crate);
     let paths_buckets = create_index(paths_index, hash_path);
     encode_index(ebml_w, paths_buckets, write_str);
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 
     // Encode and index the items.
-    ebml::start_tag(ebml_w, tag_items);
+    ebml_w.start_tag(tag_items);
     let items_index = encode_info_for_items(ecx, ebml_w, crate.node.module);
     let items_buckets = create_index(items_index, hash_node_id);
     encode_index(ebml_w, items_buckets, write_int);
-    ebml::end_tag(ebml_w);
+    ebml_w.end_tag();
 
     // Pad this, since something (LLVM, presumably) is cutting off the
     // remaining % 4 bytes.
diff --git a/src/comp/metadata/tyencode.rs b/src/comp/metadata/tyencode.rs
index e1e0cd7d68b..aa08e313dd7 100644
--- a/src/comp/metadata/tyencode.rs
+++ b/src/comp/metadata/tyencode.rs
@@ -14,6 +14,7 @@ export ac_no_abbrevs;
 export ac_use_abbrevs;
 export enc_ty;
 export enc_bounds;
+export enc_mode;
 
 type ctxt =
     // Def -> str Callback:
@@ -211,16 +212,20 @@ fn enc_proto(w: io::writer, proto: proto) {
     }
 }
 
+fn enc_mode(w: io::writer, cx: @ctxt, m: mode) {
+    alt ty::resolved_mode(cx.tcx, m) {
+      by_mutbl_ref { w.write_char('&'); }
+      by_move { w.write_char('-'); }
+      by_copy { w.write_char('+'); }
+      by_ref { w.write_char('='); }
+      by_val { w.write_char('#'); }
+    }
+}
+
 fn enc_ty_fn(w: io::writer, cx: @ctxt, ft: ty::fn_ty) {
     w.write_char('[');
     for arg: ty::arg in ft.inputs {
-        alt ty::resolved_mode(cx.tcx, arg.mode) {
-          by_mutbl_ref { w.write_char('&'); }
-          by_move { w.write_char('-'); }
-          by_copy { w.write_char('+'); }
-          by_ref { w.write_char('='); }
-          by_val { w.write_char('#'); }
-        }
+        enc_mode(w, cx, arg.mode);
         enc_ty(w, cx, arg.ty);
     }
     w.write_char(']');
diff --git a/src/comp/middle/ast_map.rs b/src/comp/middle/ast_map.rs
index aad8afe0b0c..79410158ad5 100644
--- a/src/comp/middle/ast_map.rs
+++ b/src/comp/middle/ast_map.rs
@@ -37,11 +37,8 @@ type map = std::map::map<node_id, ast_node>;
 type ctx = {map: map, mutable path: path, mutable local_id: uint};
 type vt = visit::vt<ctx>;
 
-fn map_crate(c: crate) -> map {
-    let cx = {map: std::map::new_int_hash(),
-              mutable path: [],
-              mutable local_id: 0u};
-    visit::visit_crate(c, cx, visit::mk_vt(@{
+fn mk_ast_map_visitor() -> vt {
+    ret visit::mk_vt(@{
         visit_item: map_item,
         visit_native_item: map_native_item,
         visit_expr: map_expr,
@@ -49,10 +46,33 @@ fn map_crate(c: crate) -> map {
         visit_local: map_local,
         visit_arm: map_arm
         with *visit::default_visitor()
-    }));
+    });
+}
+
+fn map_crate(c: crate) -> map {
+    let cx = {map: std::map::new_int_hash(),
+              mutable path: [],
+              mutable local_id: 0u};
+    visit::visit_crate(c, cx, mk_ast_map_visitor());
     ret cx.map;
 }
 
+// Used for items loaded from external crate that are being inlined into this
+// crate:
+fn map_decoded_item(map: map, path: path, i: @item) {
+    // I believe it is ok for the local IDs of inlined items from other crates
+    // to overlap with the local ids from this crate, so just generate the ids
+    // starting from 0.  (In particular, I think these ids are only used in
+    // alias analysis, which we will not be running on the inlined items, and
+    // even if we did I think it only needs an ordering between local
+    // variables that are simultaneously in scope).
+    let cx = {map: map,
+              mutable path: path,
+              mutable local_id: 0u};
+    let v = mk_ast_map_visitor();
+    v.visit_item(i, cx, v);
+}
+
 fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
           sp: codemap::span, id: node_id, cx: ctx, v: vt) {
     for a in decl.inputs {
diff --git a/src/comp/middle/freevars.rs b/src/comp/middle/freevars.rs
index 8df1fffa919..65a4ae627ea 100644
--- a/src/comp/middle/freevars.rs
+++ b/src/comp/middle/freevars.rs
@@ -11,6 +11,7 @@ import syntax::codemap::span;
 export annotate_freevars;
 export freevar_map;
 export freevar_info;
+export freevar_entry;
 export get_freevars;
 export has_freevars;
 
diff --git a/src/comp/middle/inline.rs b/src/comp/middle/inline.rs
new file mode 100644
index 00000000000..e212cfbcc43
--- /dev/null
+++ b/src/comp/middle/inline.rs
@@ -0,0 +1,96 @@
+import std::map::hashmap;
+import syntax::ast;
+import syntax::ast_util;
+import syntax::visit;
+import middle::typeck::method_map;
+import middle::trans::common::maps;
+import metadata::csearch;
+
+export inline_map;
+export instantiate_inlines;
+
+type inline_map = hashmap<ast::def_id, @ast::item>;
+
+enum ctxt = {
+    tcx: ty::ctxt,
+    maps: maps,
+    inline_map: inline_map,
+    mutable to_process: [@ast::item]
+};
+
+fn instantiate_inlines(tcx: ty::ctxt,
+                       maps: maps,
+                       crate: @ast::crate) -> inline_map {
+    let vt = visit::mk_vt(@{
+        visit_expr: fn@(e: @ast::expr, cx: ctxt, vt: visit::vt<ctxt>) {
+            visit::visit_expr(e, cx, vt);
+            cx.visit_expr(e);
+        }
+        with *visit::default_visitor::<ctxt>()
+    });
+    let inline_map = ast_util::new_def_id_hash();
+    let cx = ctxt({tcx: tcx, maps: maps,
+                   inline_map: inline_map, mutable to_process: []});
+    visit::visit_crate(*crate, cx, vt);
+    while !vec::is_empty(cx.to_process) {
+        let to_process = [];
+        to_process <-> cx.to_process;
+        #debug["Recursively looking at inlined items"];
+        vec::iter(to_process, {|i| visit::visit_item(i, cx, vt)});
+    }
+    ret inline_map;
+}
+
+impl methods for ctxt {
+    fn visit_expr(e: @ast::expr) {
+
+        // Look for fn items or methods that are referenced which
+        // ought to be inlined.
+
+        alt e.node {
+          ast::expr_path(_) {
+            alt self.tcx.def_map.get(e.id) {
+              ast::def_fn(did, _) {
+                self.maybe_enqueue_fn(did);
+              }
+              _ { /* not a fn item, fallthrough */ }
+            }
+          }
+          ast::expr_field(_, _, _) {
+            alt self.maps.method_map.find(e.id) {
+              some(origin) {
+                self.maybe_enqueue_impl_method(origin);
+              }
+              _ { /* not an impl method, fallthrough */ }
+            }
+          }
+          _ { /* fallthrough */ }
+        }
+    }
+
+    fn maybe_enqueue_fn(did: ast::def_id) {
+        if did.crate == ast::local_crate { ret; }
+        if self.inline_map.contains_key(did) { ret; }
+        alt csearch::maybe_get_item_ast(self.tcx, self.maps, did) {
+          none {
+            /* no AST attached, do not inline */
+            #debug["No AST attached to def %s",
+                   ty::item_path_str(self.tcx, did)];
+          }
+          some(item) { /* Found an AST, add to table: */
+            #debug["Inlining def %s", ty::item_path_str(self.tcx, did)];
+            self.to_process += [item];
+            self.inline_map.insert(did, item);
+          }
+        }
+    }
+
+    fn maybe_enqueue_impl_method(_origin: typeck::method_origin) {
+        // alt method_origin {
+        //   method_static(did) { self.maybe_enqueue_fn(did); }
+        //   method_param(_, _, _, _) | method_iface(_, _) {
+        //     /* fallthrough */
+        //   }
+        // }
+    }
+}
diff --git a/src/comp/middle/trans/alt.rs b/src/comp/middle/trans/alt.rs
index d461781e719..9e5333ade64 100644
--- a/src/comp/middle/trans/alt.rs
+++ b/src/comp/middle/trans/alt.rs
@@ -585,7 +585,7 @@ fn make_phi_bindings(bcx: block, map: [exit_node],
     if success {
         // Copy references that the alias analysis considered unsafe
         ids.values {|node_id|
-            if bcx.ccx().copy_map.contains_key(node_id) {
+            if bcx.ccx().maps.copy_map.contains_key(node_id) {
                 let local = alt bcx.fcx.lllocals.find(node_id) {
                   some(local_mem(x)) { x }
                   _ { bcx.tcx().sess.bug("Someone \
@@ -675,7 +675,7 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef,
     alt pat.node {
       ast::pat_ident(_,inner) {
         if pat_is_variant(bcx.tcx().def_map, pat) { ret bcx; }
-        if make_copy || ccx.copy_map.contains_key(pat.id) {
+        if make_copy || ccx.maps.copy_map.contains_key(pat.id) {
             let ty = node_id_type(bcx, pat.id);
             let llty = type_of::type_of(ccx, ty);
             let alloc = alloca(bcx, llty);
diff --git a/src/comp/middle/trans/base.rs b/src/comp/middle/trans/base.rs
index 4ec06b83772..e05f4e12855 100644
--- a/src/comp/middle/trans/base.rs
+++ b/src/comp/middle/trans/base.rs
@@ -21,6 +21,7 @@ import driver::session;
 import session::session;
 import front::attr;
 import middle::freevars::*;
+import middle::inline::inline_map;
 import back::{link, abi, upcall};
 import syntax::{ast, ast_util, codemap};
 import ast_util::local_def;
@@ -59,6 +60,14 @@ enum dest {
     ignore,
 }
 
+fn dest_str(ccx: crate_ctxt, d: dest) -> str {
+    alt d {
+      by_val(v) { #fmt["by_val(%s)", val_str(ccx.tn, *v)] }
+      save_in(v) { #fmt["save_in(%s)", val_str(ccx.tn, v)] }
+      ignore { "ignore" }
+    }
+}
+
 fn empty_dest_cell() -> @mutable ValueRef {
     ret @mutable llvm::LLVMGetUndef(T_nil());
 }
@@ -1561,7 +1570,7 @@ fn trans_lit(cx: block, lit: ast::lit, dest: dest) -> block {
 fn trans_unary(bcx: block, op: ast::unop, e: @ast::expr,
                un_expr: @ast::expr, dest: dest) -> block {
     // Check for user-defined method call
-    alt bcx.ccx().method_map.find(un_expr.id) {
+    alt bcx.ccx().maps.method_map.find(un_expr.id) {
       some(origin) {
         let callee_id = ast_util::op_expr_callee_id(un_expr);
         let fty = node_id_type(bcx, callee_id);
@@ -1741,7 +1750,7 @@ fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop,
     assert (lhs_res.kind == owned);
 
     // A user-defined operator method
-    alt bcx.ccx().method_map.find(ex.id) {
+    alt bcx.ccx().maps.method_map.find(ex.id) {
       some(origin) {
         let callee_id = ast_util::op_expr_callee_id(ex);
         let fty = node_id_type(bcx, callee_id);
@@ -1852,7 +1861,7 @@ fn trans_lazy_binop(bcx: block, op: lazy_binop_ty, a: @ast::expr,
 fn trans_binary(bcx: block, op: ast::binop, lhs: @ast::expr,
                 rhs: @ast::expr, dest: dest, ex: @ast::expr) -> block {
     // User-defined operators
-    alt bcx.ccx().method_map.find(ex.id) {
+    alt bcx.ccx().maps.method_map.find(ex.id) {
       some(origin) {
         let callee_id = ast_util::op_expr_callee_id(ex);
         let fty = node_id_type(bcx, callee_id);
@@ -2110,8 +2119,29 @@ fn lval_static_fn(bcx: block, fn_id: ast::def_id, id: ast::node_id,
                   substs: option<([ty::t], typeck::dict_res)>)
     -> lval_maybe_callee {
     let ccx = bcx.ccx();
+    let tcx = ccx.tcx;
     let tys = node_id_type_params(bcx, id);
-    let tpt = ty::lookup_item_type(ccx.tcx, fn_id);
+    let tpt = ty::lookup_item_type(tcx, fn_id);
+
+    // Check whether this fn has an inlined copy and, if so, redirect fn_id to
+    // the local id of the inlined copy.
+    let fn_id = {
+        if fn_id.crate == ast::local_crate {
+            fn_id
+        } else {
+            alt ccx.inline_map.find(fn_id) {
+              none { fn_id }
+              some(item) {
+                #debug["Found inlined version of %s with id %d",
+                       ty::item_path_str(tcx, fn_id),
+                       item.id];
+                {crate: ast::local_crate,
+                 node: item.id}
+              }
+            }
+        }
+    };
+
     // The awkwardness below mostly stems from the fact that we're mixing
     // monomorphized and non-monomorphized functions at the moment. If
     // monomorphizing becomes the only approach, this'll be much simpler.
@@ -2126,7 +2156,7 @@ fn lval_static_fn(bcx: block, fn_id: ast::def_id, id: ast::node_id,
             } else { none }
           }
           none {
-            alt ccx.dict_map.find(id) {
+            alt ccx.maps.dict_map.find(id) {
               some(dicts) {
                 alt impl::resolve_dicts_in_fn_ctxt(bcx.fcx, dicts) {
                   some(dicts) { monomorphic_fn(ccx, fn_id, tys, some(dicts)) }
@@ -2146,6 +2176,7 @@ fn lval_static_fn(bcx: block, fn_id: ast::def_id, id: ast::node_id,
           none {}
         }
     }
+
     let val = if fn_id.crate == ast::local_crate {
         // Internal reference.
         assert (ccx.item_ids.contains_key(fn_id.node));
@@ -2181,7 +2212,7 @@ fn lval_static_fn(bcx: block, fn_id: ast::def_id, id: ast::node_id,
                             static_tis: tis,
                             tydescs: tydescs,
                             param_bounds: tpt.bounds,
-                            origins: ccx.dict_map.find(id)});
+                            origins: ccx.maps.dict_map.find(id)});
     }
     ret {bcx: bcx, val: val, kind: owned, env: null_env, generic: gen};
 }
@@ -2347,7 +2378,7 @@ fn trans_index(cx: block, ex: @ast::expr, base: @ast::expr,
 
 fn expr_is_lval(bcx: block, e: @ast::expr) -> bool {
     let ccx = bcx.ccx();
-    ty::expr_is_lval(ccx.method_map, e)
+    ty::expr_is_lval(ccx.maps.method_map, e)
 }
 
 fn trans_callee(bcx: block, e: @ast::expr) -> lval_maybe_callee {
@@ -2356,7 +2387,7 @@ fn trans_callee(bcx: block, e: @ast::expr) -> lval_maybe_callee {
       ast::expr_field(base, ident, _) {
         // Lval means this is a record field, so not a method
         if !expr_is_lval(bcx, e) {
-            alt bcx.ccx().method_map.find(e.id) {
+            alt bcx.ccx().maps.method_map.find(e.id) {
               some(origin) { // An impl method
                 ret impl::trans_method_callee(bcx, e.id, base, origin);
               }
@@ -2553,7 +2584,7 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef,
             val = do_spill_noroot(bcx, val);
             copied = true;
         }
-        if ccx.copy_map.contains_key(e.id) && lv.kind != temporary {
+        if ccx.maps.copy_map.contains_key(e.id) && lv.kind != temporary {
             if !copied {
                 let alloc = alloc_ty(bcx, e_ty);
                 bcx = copy_val(alloc.bcx, INIT, alloc.val,
@@ -2568,7 +2599,7 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef,
     } else if arg_mode == ast::by_copy || arg_mode == ast::by_move {
         let {bcx: cx, val: alloc} = alloc_ty(bcx, e_ty);
         let move_out = arg_mode == ast::by_move ||
-            ccx.last_uses.contains_key(e.id);
+            ccx.maps.last_uses.contains_key(e.id);
         bcx = cx;
         if lv.kind == temporary { revoke_clean(bcx, val); }
         if lv.kind == owned || !ty::type_is_immediate(e_ty) {
@@ -2983,7 +3014,11 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
     let tcx = bcx.tcx();
     debuginfo::update_source_pos(bcx, e.span);
 
-    #debug["trans_expr(%s,%?)", expr_to_str(e), dest];
+    #debug["trans_expr(e=%s,e.id=%d,dest=%s,ty=%s)",
+           expr_to_str(e),
+           e.id,
+           dest_str(bcx.ccx(), dest),
+           ty_to_str(tcx, expr_ty(bcx, e))];
 
     if expr_is_lval(bcx, e) {
         ret lval_to_dps(bcx, e, dest);
@@ -3056,7 +3091,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
       }
       ast::expr_index(base, idx) {
         // If it is here, it's not an lval, so this is a user-defined index op
-        let origin = bcx.ccx().method_map.get(e.id);
+        let origin = bcx.ccx().maps.method_map.get(e.id);
         let callee_id = ast_util::op_expr_callee_id(e);
         let fty = node_id_type(bcx, callee_id);
         ret trans_call_inner(bcx, fty, {|bcx|
@@ -3128,7 +3163,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
         assert kind == owned;
         ret store_temp_expr(bcx, DROP_EXISTING, addr, src_r,
                             expr_ty(bcx, src),
-                            bcx.ccx().last_uses.contains_key(src.id));
+                            bcx.ccx().maps.last_uses.contains_key(src.id));
       }
       ast::expr_move(dst, src) {
         // FIXME: calculate copy init-ness in typestate.
@@ -3164,7 +3199,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
 fn lval_to_dps(bcx: block, e: @ast::expr, dest: dest) -> block {
     let lv = trans_lval(bcx, e), ccx = bcx.ccx();
     let {bcx, val, kind} = lv;
-    let last_use = kind == owned && ccx.last_uses.contains_key(e.id);
+    let last_use = kind == owned && ccx.maps.last_uses.contains_key(e.id);
     let ty = expr_ty(bcx, e);
     alt dest {
       by_val(cell) {
@@ -3717,8 +3752,8 @@ fn alloc_local(cx: block, local: @ast::local) -> block {
     // Do not allocate space for locals that can be kept immediate.
     let ccx = cx.ccx();
     if option::is_some(simple_name) &&
-       !ccx.mutbl_map.contains_key(local.node.pat.id) &&
-       !ccx.last_uses.contains_key(local.node.pat.id) &&
+       !ccx.maps.mutbl_map.contains_key(local.node.pat.id) &&
+       !ccx.maps.last_uses.contains_key(local.node.pat.id) &&
        ty::type_is_immediate(t) {
         alt local.node.init {
           some({op: ast::init_assign, _}) { ret cx; }
@@ -4258,6 +4293,12 @@ fn trans_mod(ccx: crate_ctxt, m: ast::_mod) {
     for item in m.items { trans_item(ccx, *item); }
 }
 
+fn trans_inlined_items(ccx: crate_ctxt, inline_map: inline_map) {
+    inline_map.values {|item|
+        trans_item(ccx, *item)
+    }
+}
+
 fn get_pair_fn_ty(llpairty: TypeRef) -> TypeRef {
     // Bit of a kludge: pick the fn typeref out of the pair.
     ret struct_elt(llpairty, 0u);
@@ -4290,6 +4331,9 @@ fn register_fn_fuller(ccx: crate_ctxt, sp: span, path: path, _flav: str,
     ccx.item_ids.insert(node_id, llfn);
     ccx.item_symbols.insert(node_id, ps);
 
+    #debug["register_fn_fuller created fn %s for item %d with path %s",
+           val_str(ccx.tn, llfn), node_id, ast_map::path_to_str(path)];
+
     let is_main = is_main_name(path) && !ccx.sess.building_library;
     if is_main { create_main_wrapper(ccx, sp, llfn, node_type); }
 }
@@ -4519,6 +4563,13 @@ fn collect_items(ccx: crate_ctxt, crate: @ast::crate) {
     }));
 }
 
+fn collect_inlined_items(ccx: crate_ctxt, inline_map: inline::inline_map) {
+    let abi = @mutable none::<ast::native_abi>;
+    inline_map.values {|item|
+        collect_item(ccx, abi, item);
+    }
+}
+
 // The constant translation pass.
 fn trans_constant(ccx: crate_ctxt, it: @ast::item) {
     alt it.node {
@@ -4718,10 +4769,8 @@ fn write_abi_version(ccx: crate_ctxt) {
 }
 
 fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
-               output: str, emap: resolve::exp_map, amap: ast_map::map,
-               mutbl_map: mutbl::mutbl_map, copy_map: alias::copy_map,
-               last_uses: last_use::last_uses, impl_map: resolve::impl_map,
-               method_map: typeck::method_map, dict_map: typeck::dict_map)
+               output: str, emap: resolve::exp_map, maps: maps,
+               inline_map: inline::inline_map)
     -> (ModuleRef, link::link_meta) {
     let sha = std::sha1::mk_sha1();
     let link_meta = link::build_link_meta(sess, *crate, output, sha);
@@ -4769,6 +4818,7 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
     } else {
         option::none
     };
+
     let ccx =
         @{sess: sess,
           llmod: llmod,
@@ -4777,7 +4827,6 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
           externs: new_str_hash::<ValueRef>(),
           intrinsics: intrinsics,
           item_ids: new_int_hash::<ValueRef>(),
-          ast_map: amap,
           exp_map: emap,
           item_symbols: new_int_hash::<str>(),
           mutable main_fn: none::<ValueRef>,
@@ -4796,12 +4845,8 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
           type_sha1s: ty::new_ty_hash(),
           type_short_names: ty::new_ty_hash(),
           tcx: tcx,
-          mutbl_map: mutbl_map,
-          copy_map: copy_map,
-          last_uses: last_uses,
-          impl_map: impl_map,
-          method_map: method_map,
-          dict_map: dict_map,
+          maps: maps,
+          inline_map: inline_map,
           stats:
               {mutable n_static_tydescs: 0u,
                mutable n_derived_tydescs: 0u,
@@ -4823,8 +4868,10 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
           dbg_cx: dbg_cx,
           mutable do_not_commit_warning_issued: false};
     collect_items(ccx, crate);
+    collect_inlined_items(ccx, inline_map);
     trans_constants(ccx, crate);
     trans_mod(ccx, crate.node.module);
+    trans_inlined_items(ccx, inline_map);
     fill_crate_map(ccx, crate_map);
     emit_tydescs(ccx);
     gen_shape_tables(ccx);
diff --git a/src/comp/middle/trans/build.rs b/src/comp/middle/trans/build.rs
index 0559a6b02af..767b2c0b621 100644
--- a/src/comp/middle/trans/build.rs
+++ b/src/comp/middle/trans/build.rs
@@ -322,6 +322,9 @@ fn Load(cx: block, PointerVal: ValueRef) -> ValueRef {
 
 fn Store(cx: block, Val: ValueRef, Ptr: ValueRef) {
     if cx.unreachable { ret; }
+    #debug["Store %s -> %s",
+           val_str(cx.ccx().tn, Val),
+           val_str(cx.ccx().tn, Ptr)];
     llvm::LLVMBuildStore(B(cx), Val, Ptr);
 }
 
diff --git a/src/comp/middle/trans/closure.rs b/src/comp/middle/trans/closure.rs
index 3f7274deae4..d8a66750e90 100644
--- a/src/comp/middle/trans/closure.rs
+++ b/src/comp/middle/trans/closure.rs
@@ -277,6 +277,7 @@ fn store_environment(
     let cbox_ty = tuplify_box_ty(tcx, cdata_ty);
     let cboxptr_ty = ty::mk_ptr(tcx, {ty:cbox_ty, mutbl:ast::m_imm});
     let llbox = cast_if_we_can(bcx, llbox, cboxptr_ty);
+    #debug["tuplify_box_ty = %s", ty_to_str(tcx, cbox_ty)];
 
     // If necessary, copy tydescs describing type parameters into the
     // appropriate slot in the closure.
@@ -298,8 +299,9 @@ fn store_environment(
     }
 
     // Copy expr values into boxed bindings.
-    // Silly check
     vec::iteri(bound_values) { |i, bv|
+        #debug["Copy %s into closure", ev_to_str(ccx, bv)];
+
         if (!ccx.sess.opts.no_asm_comments) {
             add_comment(bcx, #fmt("Copy %s into closure",
                                   ev_to_str(ccx, bv)));
diff --git a/src/comp/middle/trans/common.rs b/src/comp/middle/trans/common.rs
index 1c04bc8c4c6..c546ce5341d 100644
--- a/src/comp/middle/trans/common.rs
+++ b/src/comp/middle/trans/common.rs
@@ -19,6 +19,7 @@ import lib::llvm::{ModuleRef, ValueRef, TypeRef, BasicBlockRef, BuilderRef};
 import lib::llvm::{True, False, Bool};
 import metadata::csearch;
 import ast_map::path;
+import middle::inline::inline_map;
 
 type namegen = fn@(str) -> str;
 fn new_namegen() -> namegen {
@@ -63,6 +64,16 @@ type stats =
 
 resource BuilderRef_res(B: BuilderRef) { llvm::LLVMDisposeBuilder(B); }
 
+// Misc. auxiliary maps used in the crate_ctxt
+type maps = {
+    mutbl_map: middle::mutbl::mutbl_map,
+    copy_map: middle::alias::copy_map,
+    last_uses: middle::last_use::last_uses,
+    impl_map: middle::resolve::impl_map,
+    method_map: middle::typeck::method_map,
+    dict_map: middle::typeck::dict_map
+};
+
 // Crate context.  Every crate we compile has one of these.
 type crate_ctxt = @{
      sess: session::session,
@@ -72,7 +83,6 @@ type crate_ctxt = @{
      externs: hashmap<str, ValueRef>,
      intrinsics: hashmap<str, ValueRef>,
      item_ids: hashmap<ast::node_id, ValueRef>,
-     ast_map: ast_map::map,
      exp_map: resolve::exp_map,
      item_symbols: hashmap<ast::node_id, str>,
      mutable main_fn: option<ValueRef>,
@@ -91,12 +101,8 @@ type crate_ctxt = @{
      type_sha1s: hashmap<ty::t, str>,
      type_short_names: hashmap<ty::t, str>,
      tcx: ty::ctxt,
-     mutbl_map: mutbl::mutbl_map,
-     copy_map: alias::copy_map,
-     last_uses: last_use::last_uses,
-     impl_map: resolve::impl_map,
-     method_map: typeck::method_map,
-     dict_map: typeck::dict_map,
+     maps: maps,
+     inline_map: inline_map,
      stats: stats,
      upcalls: @upcall::upcalls,
      tydesc_type: TypeRef,
diff --git a/src/comp/middle/trans/debuginfo.rs b/src/comp/middle/trans/debuginfo.rs
index 47024432b4e..47a3d2e5716 100644
--- a/src/comp/middle/trans/debuginfo.rs
+++ b/src/comp/middle/trans/debuginfo.rs
@@ -780,7 +780,7 @@ fn create_function(fcx: fn_ctxt) -> @metadata<subprogram_md> {
     let sp = option::get(fcx.span);
     log(debug, codemap::span_to_str(sp, cx.sess.codemap));
 
-    let (ident, ret_ty, id) = alt cx.ast_map.get(fcx.id) {
+    let (ident, ret_ty, id) = alt cx.tcx.items.get(fcx.id) {
       ast_map::node_item(item, _) {
         alt item.node {
           ast::item_fn(decl, _, _) | ast::item_res(decl, _, _, _, _) {
diff --git a/src/comp/middle/trans/impl.rs b/src/comp/middle/trans/impl.rs
index 45c9499f197..00345e8ae02 100644
--- a/src/comp/middle/trans/impl.rs
+++ b/src/comp/middle/trans/impl.rs
@@ -134,7 +134,7 @@ fn trans_vtable_callee(bcx: block, env: callee_env, dict: ValueRef,
                                 static_tis: tis,
                                 tydescs: tydescs,
                                 param_bounds: method.tps,
-                                origins: ccx.dict_map.find(callee_id)});
+                                origins: ccx.maps.dict_map.find(callee_id)});
     }
     {bcx: bcx, val: mptr, kind: owned,
      env: env,
@@ -531,7 +531,7 @@ fn trans_cast(bcx: block, val: @ast::expr, id: ast::node_id, dest: dest)
     let result = get_dest_addr(dest);
     Store(bcx, box, PointerCast(bcx, GEPi(bcx, result, [0, 1]),
                                 T_ptr(val_ty(box))));
-    let {bcx, val: dict} = get_dict(bcx, ccx.dict_map.get(id)[0]);
+    let {bcx, val: dict} = get_dict(bcx, ccx.maps.dict_map.get(id)[0]);
     Store(bcx, dict, PointerCast(bcx, GEPi(bcx, result, [0, 0]),
                                  T_ptr(val_ty(dict))));
     bcx
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index a0189264446..a7e218e581b 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -129,6 +129,7 @@ export param_bound, param_bounds, bound_copy, bound_send, bound_iface;
 export param_bounds_to_kind;
 export default_arg_mode_for_ty;
 export item_path;
+export item_path_str;
 
 // Data types
 
@@ -2174,6 +2175,10 @@ fn substd_enum_variants(cx: ctxt, id: ast::def_id, tps: [ty::t])
     }
 }
 
+fn item_path_str(cx: ctxt, id: ast::def_id) -> str {
+    ast_map::path_to_str(item_path(cx, id))
+}
+
 fn item_path(cx: ctxt, id: ast::def_id) -> ast_map::path {
     if id.crate != ast::local_crate {
         csearch::get_item_path(cx, id)
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index 88753b06091..0343c2c102f 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -444,8 +444,18 @@ fn ty_of_item(tcx: ty::ctxt, mode: mode, it: @ast::item)
         // call to resolve any named types.
         let tpt = {
             let t0 = ast_ty_to_ty(tcx, mode, t);
-            {bounds: ty_param_bounds(tcx, mode, tps),
-             ty: ty::mk_with_id(tcx, t0, def_id)}
+            let t1 = {
+                // Do not associate a def id with a named, parameterized type
+                // like "foo<X>".  This is because otherwise ty_to_str will
+                // print the name as merely "foo", as it has no way to
+                // reconstruct the value of X.
+                if vec::is_empty(tps) {
+                    ty::mk_with_id(tcx, t0, def_id)
+                } else {
+                    t0
+                }
+            };
+            {bounds: ty_param_bounds(tcx, mode, tps), ty: t1}
         };
         tcx.tcache.insert(local_def(it.id), tpt);
         ret tpt;
diff --git a/src/comp/rustc.rc b/src/comp/rustc.rc
index 0b8ce111f1f..8102e4d8cd8 100644
--- a/src/comp/rustc.rc
+++ b/src/comp/rustc.rc
@@ -28,6 +28,7 @@ mod middle {
         mod shape;
         mod debuginfo;
     }
+    mod inline;
     mod ty;
     mod ast_map;
     mod resolve;
@@ -121,6 +122,8 @@ mod metadata {
     mod common;
     mod tyencode;
     mod tydecode;
+    mod astencode;
+    mod astencode_gen;
     mod encoder;
     mod decoder;
     mod creader;
diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs
index 446f74c8680..d5b33971f8d 100644
--- a/src/comp/syntax/ast_util.rs
+++ b/src/comp/syntax/ast_util.rs
@@ -19,6 +19,14 @@ fn path_name_i(idents: [ident]) -> str { str::connect(idents, "::") }
 
 fn local_def(id: node_id) -> def_id { ret {crate: local_crate, node: id}; }
 
+fn stmt_id(s: stmt) -> node_id {
+    alt s.node {
+      stmt_decl(_, id) { id }
+      stmt_expr(_, id) { id }
+      stmt_semi(_, id) { id }
+    }
+}
+
 fn variant_def_ids(d: def) -> {enm: def_id, var: def_id} {
     alt d { def_variant(enum_id, var_id) {
             ret {enm: enum_id, var: var_id}; }
diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs
index d161d27c020..00624bdf270 100644
--- a/src/comp/syntax/fold.rs
+++ b/src/comp/syntax/fold.rs
@@ -125,9 +125,10 @@ fn fold_attribute_(at: attribute, fmi: fn@(&&@meta_item) -> @meta_item) ->
 }
 //used in noop_fold_native_item and noop_fold_fn_decl
 fn fold_arg_(a: arg, fld: ast_fold) -> arg {
-    ret {ty: fld.fold_ty(a.ty),
-         ident: fld.fold_ident(a.ident)
-         with a};
+    ret {mode: a.mode,
+         ty: fld.fold_ty(a.ty),
+         ident: fld.fold_ident(a.ident),
+         id: fld.new_id(a.id)};
 }
 //used in noop_fold_expr, and possibly elsewhere in the future
 fn fold_mac_(m: mac, fld: ast_fold) -> mac {
@@ -156,6 +157,23 @@ fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
          constraints: vec::map(decl.constraints, fld.fold_constr)}
 }
 
+fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
+    alt tpb {
+      bound_copy | bound_send { tpb }
+      bound_iface(ty) { bound_iface(fld.fold_ty(ty)) }
+    }
+}
+
+fn fold_ty_param(tp: ty_param, fld: ast_fold) -> ty_param {
+    {ident: tp.ident,
+     id: fld.new_id(tp.id),
+     bounds: @vec::map(*tp.bounds, fold_ty_param_bound(_, fld))}
+}
+
+fn fold_ty_params(tps: [ty_param], fld: ast_fold) -> [ty_param] {
+    vec::map(tps, fold_ty_param(_, fld))
+}
+
 fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
     let fold_meta_item = bind fold_meta_item_(_, fld);
     let fold_attribute = bind fold_attribute_(_, fold_meta_item);
@@ -202,11 +220,12 @@ fn noop_fold_native_item(&&ni: @native_item, fld: ast_fold) -> @native_item {
                                   cf: fdec.cf,
                                   constraints:
                                       vec::map(fdec.constraints,
-                                               fld.fold_constr)}, typms)
+                                               fld.fold_constr)},
+                                 fold_ty_params(typms, fld))
                 }
               },
-          id: ni.id,
-          span: ni.span};
+          id: fld.new_id(ni.id),
+          span: fld.new_span(ni.span)};
 }
 
 fn noop_fold_item(&&i: @item, fld: ast_fold) -> @item {
@@ -215,9 +234,9 @@ fn noop_fold_item(&&i: @item, fld: ast_fold) -> @item {
 
     ret @{ident: fld.fold_ident(i.ident),
           attrs: vec::map(i.attrs, fold_attribute),
-          id: i.id,
+          id: fld.new_id(i.id),
           node: fld.fold_item_underscore(i.node),
-          span: i.span};
+          span: fld.new_span(i.span)};
 }
 
 fn noop_fold_class_item(&&ci: @class_item, fld: ast_fold)
@@ -238,17 +257,20 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
     ret alt i {
           item_const(t, e) { item_const(fld.fold_ty(t), fld.fold_expr(e)) }
           item_fn(decl, typms, body) {
-              let body = fld.fold_block(body);
-              item_fn(fold_fn_decl(decl, fld), typms, body)
+              item_fn(fold_fn_decl(decl, fld),
+                      fold_ty_params(typms, fld),
+                      fld.fold_block(body))
           }
           item_mod(m) { item_mod(fld.fold_mod(m)) }
           item_native_mod(nm) { item_native_mod(fld.fold_native_mod(nm)) }
-          item_ty(t, typms) { item_ty(fld.fold_ty(t), typms) }
+          item_ty(t, typms) { item_ty(fld.fold_ty(t),
+                                      fold_ty_params(typms, fld)) }
           item_enum(variants, typms) {
-            item_enum(vec::map(variants, fld.fold_variant), typms)
+            item_enum(vec::map(variants, fld.fold_variant),
+                      fold_ty_params(typms, fld))
           }
           item_class(typms, items, id, ctor_decl, ctor_body) {
-              item_class(typms,
+              item_class(fold_ty_params(typms, fld),
                          vec::map(items, fld.fold_class_item),
                          id,
                          fold_fn_decl(ctor_decl, fld),
@@ -260,16 +282,23 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
           }
           item_iface(tps, methods) { item_iface(tps, methods) }
           item_res(decl, typms, body, did, cid) {
-            item_res(fold_fn_decl(decl, fld), typms, fld.fold_block(body),
-                     did, cid)
+            item_res(fold_fn_decl(decl, fld),
+                     fold_ty_params(typms, fld),
+                     fld.fold_block(body),
+                     did,
+                     cid)
           }
         };
 }
 
 fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
     ret @{ident: fld.fold_ident(m.ident),
+          attrs: m.attrs,
+          tps: fold_ty_params(m.tps, fld),
           decl: fold_fn_decl(m.decl, fld),
-          body: fld.fold_block(m.body) with *m};
+          body: fld.fold_block(m.body),
+          id: fld.new_id(m.id),
+          span: fld.new_span(m.span)};
 }
 
 
@@ -277,15 +306,15 @@ fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
     ret {view_items: vec::map(b.view_items, fld.fold_view_item),
          stmts: vec::map(b.stmts, fld.fold_stmt),
          expr: option::map(b.expr, fld.fold_expr),
-         id: b.id,
+         id: fld.new_id(b.id),
          rules: b.rules};
 }
 
 fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
     ret alt s {
-      stmt_decl(d, nid) { stmt_decl(fld.fold_decl(d), nid) }
-      stmt_expr(e, nid) { stmt_expr(fld.fold_expr(e), nid) }
-      stmt_semi(e, nid) { stmt_semi(fld.fold_expr(e), nid) }
+      stmt_decl(d, nid) { stmt_decl(fld.fold_decl(d), fld.new_id(nid)) }
+      stmt_expr(e, nid) { stmt_expr(fld.fold_expr(e), fld.new_id(nid)) }
+      stmt_semi(e, nid) { stmt_semi(fld.fold_expr(e), fld.new_id(nid)) }
     };
 }
 
@@ -459,7 +488,7 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
 }
 
 fn noop_fold_constr(c: constr_, fld: ast_fold) -> constr_ {
-    {path: fld.fold_path(c.path), args: c.args, id: c.id}
+    {path: fld.fold_path(c.path), args: c.args, id: fld.new_id(c.id)}
 }
 
 // ...nor do modules
@@ -475,7 +504,7 @@ fn noop_fold_native_mod(nm: native_mod, fld: ast_fold) -> native_mod {
 
 fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
     fn fold_variant_arg_(va: variant_arg, fld: ast_fold) -> variant_arg {
-        ret {ty: fld.fold_ty(va.ty), id: va.id};
+        ret {ty: fld.fold_ty(va.ty), id: fld.new_id(va.id)};
     }
     let fold_variant_arg = bind fold_variant_arg_(_, fld);
     let args = vec::map(v.args, fold_variant_arg);
@@ -490,7 +519,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
     };
     ret {name: v.name,
          attrs: attrs,
-         args: args, id: v.id,
+         args: args, id: fld.new_id(v.id),
          disr_expr: de};
 }
 
@@ -513,7 +542,7 @@ fn noop_fold_local(l: local_, fld: ast_fold) -> local_ {
                                               expr: fld.fold_expr(init.expr)})
                }
              },
-         id: l.id};
+         id: fld.new_id(l.id)};
 }
 
 /* temporarily eta-expand because of a compiler bug with using `fn<T>` as a
@@ -621,7 +650,7 @@ fn make_fold(afp: ast_fold_precursor) -> ast_fold {
            class_method(i) {
                class_method(afp.fold_item(i, f))
            }
-            }}, span: ci.span}
+            }}, span: afp.new_span(ci.span)}
     }
     fn f_item_underscore(afp: ast_fold_precursor, f: ast_fold, i: item_) ->
        item_ {
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 1a8fbdd917a..0de75d88422 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -2280,9 +2280,6 @@ fn fn_expr_lookahead(tok: token::token) -> bool {
 fn parse_item(p: parser, attrs: [ast::attribute]) -> option<@ast::item> {
     if eat_word(p, "const") {
         ret some(parse_item_const(p, attrs));
-    } else if eat_word(p, "inline") {
-        expect_word(p, "fn");
-        ret some(parse_item_fn(p, ast::impure_fn, attrs));
     } else if is_word(p, "fn") && !fn_expr_lookahead(p.look_ahead(1u)) {
         p.bump();
         ret some(parse_item_fn(p, ast::impure_fn, attrs));
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index 76ab2b4ecb5..5f92b5d5beb 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -89,6 +89,8 @@ fn stmt_to_str(s: ast::stmt) -> str { be to_str(s, print_stmt); }
 
 fn item_to_str(i: @ast::item) -> str { be to_str(i, print_item); }
 
+fn attr_to_str(i: ast::attribute) -> str { be to_str(i, print_attribute); }
+
 fn typarams_to_str(tps: [ast::ty_param]) -> str {
     be to_str(tps, print_type_params)
 }
diff --git a/src/etc/gen-astencode b/src/etc/gen-astencode
new file mode 100755
index 00000000000..9e598fafe2f
--- /dev/null
+++ b/src/etc/gen-astencode
@@ -0,0 +1,57 @@
+#!/bin/sh
+
+M=src/comp/metadata
+GEN_TYPES="syntax::ast::item syntax::ast::def middle::typeck::method_origin \
+           middle::freevars::freevar_entry syntax::ast::def_id"
+
+# Find serializer tool:
+for S in build/*/stage2/bin/serializer; do
+
+    # Find rustc:
+    D=$(dirname "$S")
+    R="${D}/rustc"
+    if [ ! -x "$R" ]; then
+        echo "rustc not found or not executable at path '$R'"
+        exit 1
+    fi
+
+    echo "Generating src/comp/metadata/astencode_gen.rs"
+
+    # First, generate dummy fns so that the compiler can type
+    # everything.
+    echo "// TEMPORARY DEFINITIONS: re-run gen-astencode" \
+        > $M/astencode_gen.rs
+    for T in $GEN_TYPES; do
+      echo "fn serialize_${T//::/_}<S>(_s: S, _v: $T) {}" \
+          >> $M/astencode_gen.rs
+      echo "fn deserialize_${T//::/_}<S>(_s: S) -> $T { fail; }" \
+          >> $M/astencode_gen.rs
+    done
+
+    # Generate the real code into a temporary file.
+    if ! "$S" src/comp/rustc.rc $GEN_TYPES > tmp.$$.rs
+    then
+        echo ""
+        echo ""
+        echo "****************************************"
+        echo "* Compilation errors encountered       *"
+        echo "*                                      *"
+        echo "* Dummy versions of the AST encoder    *"
+        echo "* have been left in astencode_gen.rs.  *"
+        echo "* Fix the compilation errors and rerun *"
+        echo "* this script to generate the real     *"
+        echo "* versions.                            *"
+        echo "****************************************"
+        rm tmp.$$.rs
+        exit 1
+    fi
+
+    # Copy over into the final destination and clean up.
+    "$R" --pretty normal tmp.$$.rs > $M/astencode_gen.rs
+    # rm -f tmp.$$.rs
+    exit 0
+done
+
+# If we made it this far, must not have found any
+# serializer:
+echo "serializer tool not found."
diff --git a/src/etc/tidy.py b/src/etc/tidy.py
index 4974bf74c5b..ca57f686dbb 100644
--- a/src/etc/tidy.py
+++ b/src/etc/tidy.py
@@ -18,8 +18,11 @@ def report_err(s):
     print("%s:%d: %s" % (fileinput.filename(), fileinput.filelineno(), s))
     err=1
 
+file_names = [s for s in sys.argv[1:] if not s.endswith("_gen.rs")]
+
 try:
-    for line in fileinput.input(openhook=fileinput.hook_encoded("utf-8")):
+    for line in fileinput.input(file_names,
+                                openhook=fileinput.hook_encoded("utf-8")):
         if (line.find('\t') != -1 and
             fileinput.filename().find("Makefile") == -1):
             report_err("tab character")
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index f225840eacd..52cb3adbc5a 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -407,7 +407,6 @@ fn pop<T>(&v: [const T]) -> T unsafe {
     val
 }
 
-#[inline]
 /*
 Function: push
 
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 45faf62cf7d..9e39042ded1 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -6,11 +6,31 @@
 import core::option;
 import option::{some, none};
 
+export doc;
+
+export new_doc;
+export doc_at;
+export maybe_get_doc;
+export get_doc;
+export docs;
+export tagged_docs;
+export doc_data;
+export doc_as_str;
+export doc_as_u8;
+export doc_as_u16;
+export doc_as_u32;
+export doc_as_u64;
+export doc_as_i8;
+export doc_as_i16;
+export doc_as_i32;
+export doc_as_i64;
+export writer;
+export mk_writer;
+
 type ebml_tag = {id: uint, size: uint};
 
 type ebml_state = {ebml_tag: ebml_tag, tag_pos: uint, data_pos: uint};
 
-
 // TODO: When we have module renaming, make "reader" and "writer" separate
 // modules within this file.
 
@@ -19,35 +39,29 @@ type doc = {data: @[u8], start: uint, end: uint};
 
 type tagged_doc = {tag: uint, doc: doc};
 
-fn vu64_at(data: [u8], start: uint) -> {val: u64, next: uint} {
+fn vuint_at(data: [u8], start: uint) -> {val: uint, next: uint} {
     let a = data[start];
     if a & 0x80u8 != 0u8 {
-        ret {val: (a & 0x7fu8) as u64, next: start + 1u};
+        ret {val: (a & 0x7fu8) as uint, next: start + 1u};
     }
     if a & 0x40u8 != 0u8 {
-        ret {val: ((a & 0x3fu8) as u64) << 8u64 |
-                 (data[start + 1u] as u64),
+        ret {val: ((a & 0x3fu8) as uint) << 8u |
+                 (data[start + 1u] as uint),
              next: start + 2u};
     } else if a & 0x20u8 != 0u8 {
-        ret {val: ((a & 0x1fu8) as u64) << 16u64 |
-                 (data[start + 1u] as u64) << 8u64 |
-                 (data[start + 2u] as u64),
+        ret {val: ((a & 0x1fu8) as uint) << 16u |
+                 (data[start + 1u] as uint) << 8u |
+                 (data[start + 2u] as uint),
              next: start + 3u};
     } else if a & 0x10u8 != 0u8 {
-        ret {val: ((a & 0x0fu8) as u64) << 24u64 |
-                 (data[start + 1u] as u64) << 16u64 |
-                 (data[start + 2u] as u64) << 8u64 |
-                 (data[start + 3u] as u64),
+        ret {val: ((a & 0x0fu8) as uint) << 24u |
+                 (data[start + 1u] as uint) << 16u |
+                 (data[start + 2u] as uint) << 8u |
+                 (data[start + 3u] as uint),
              next: start + 4u};
     } else { #error("vint too big"); fail; }
 }
 
-fn vuint_at(data: [u8], start: uint) -> {val: uint, next: uint} {
-    let {val, next} = vu64_at(data, start);
-    ret {val: val as uint, next: next};
-}
-
-
 fn new_doc(data: @[u8]) -> doc {
     ret {data: data, start: 0u, end: vec::len::<u8>(*data)};
 }
@@ -77,7 +91,7 @@ fn get_doc(d: doc, tg: uint) -> doc {
     alt maybe_get_doc(d, tg) {
       some(d) { ret d; }
       none {
-        #error("failed to find block with enum %u", tg);
+        #error("failed to find block with tag %u", tg);
         fail;
       }
     }
@@ -107,111 +121,144 @@ fn tagged_docs(d: doc, tg: uint, it: fn(doc)) {
 
 fn doc_data(d: doc) -> [u8] { ret vec::slice::<u8>(*d.data, d.start, d.end); }
 
-fn doc_str(d: doc) -> str { ret str::from_bytes(doc_data(d)); }
-
-fn be_u64_from_bytes(data: @[u8], start: uint, size: uint) -> u64 {
-    let sz = size;
-    assert (sz <= 4u);
-    let val = 0_u64;
-    let pos = start;
-    while sz > 0u {
-        sz -= 1u;
-        val += (data[pos] as u64) << ((sz * 8u) as u64);
-        pos += 1u;
-    }
-    ret val;
-}
+fn doc_as_str(d: doc) -> str { ret str::from_bytes(doc_data(d)); }
 
 fn doc_as_u8(d: doc) -> u8 {
     assert d.end == d.start + 1u;
     ret (*d.data)[d.start];
 }
 
-fn doc_as_vu64(d: doc) -> u64 {
-    ret vu64_at(*d.data, d.start).val;
+fn doc_as_u16(d: doc) -> u16 {
+    assert d.end == d.start + 2u;
+    ret io::u64_from_be_bytes(*d.data, d.start, 2u) as u16;
+}
+
+fn doc_as_u32(d: doc) -> u32 {
+    assert d.end == d.start + 4u;
+    ret io::u64_from_be_bytes(*d.data, d.start, 4u) as u32;
 }
 
-fn doc_as_vuint(d: doc) -> uint {
-    ret vuint_at(*d.data, d.start).val;
+fn doc_as_u64(d: doc) -> u64 {
+    assert d.end == d.start + 8u;
+    ret io::u64_from_be_bytes(*d.data, d.start, 8u);
 }
 
+fn doc_as_i8(d: doc) -> i8 { doc_as_u8(d) as i8 }
+fn doc_as_i16(d: doc) -> i16 { doc_as_u16(d) as i16 }
+fn doc_as_i32(d: doc) -> i32 { doc_as_u32(d) as i32 }
+fn doc_as_i64(d: doc) -> i64 { doc_as_u64(d) as i64 }
+
 // ebml writing
 type writer = {writer: io::writer, mutable size_positions: [uint]};
 
-fn write_sized_vu64(w: io::writer, n: u64, size: uint) {
+fn write_sized_vuint(w: io::writer, n: uint, size: uint) {
     let buf: [u8];
     alt size {
       1u { buf = [0x80u8 | (n as u8)]; }
-      2u { buf = [0x40u8 | ((n >> 8_u64) as u8), n as u8]; }
+      2u { buf = [0x40u8 | ((n >> 8_u) as u8), n as u8]; }
       3u {
-        buf = [0x20u8 | ((n >> 16_u64) as u8), (n >> 8_u64) as u8,
+        buf = [0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8,
                n as u8];
       }
       4u {
-        buf = [0x10u8 | ((n >> 24_u64) as u8), (n >> 16_u64) as u8,
-               (n >> 8_u64) as u8, n as u8];
+        buf = [0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
+               (n >> 8_u) as u8, n as u8];
       }
-      _ { #error("vint to write too big"); fail; }
+      _ { fail #fmt("vint to write too big: %?", n); }
     }
     w.write(buf);
 }
 
-fn write_vu64(w: io::writer, n: u64) {
-    if n < 0x7f_u64 { write_sized_vu64(w, n, 1u); ret; }
-    if n < 0x4000_u64 { write_sized_vu64(w, n, 2u); ret; }
-    if n < 0x200000_u64 { write_sized_vu64(w, n, 3u); ret; }
-    if n < 0x10000000_u64 { write_sized_vu64(w, n, 4u); ret; }
-    #error("vint to write too big");
-    fail;
+fn write_vuint(w: io::writer, n: uint) {
+    if n < 0x7f_u { write_sized_vuint(w, n, 1u); ret; }
+    if n < 0x4000_u { write_sized_vuint(w, n, 2u); ret; }
+    if n < 0x200000_u { write_sized_vuint(w, n, 3u); ret; }
+    if n < 0x10000000_u { write_sized_vuint(w, n, 4u); ret; }
+    fail #fmt("vint to write too big: %?", n);
 }
 
-fn create_writer(w: io::writer) -> writer {
+fn mk_writer(w: io::writer) -> writer {
     let size_positions: [uint] = [];
     ret {writer: w, mutable size_positions: size_positions};
 }
 
-
 // TODO: Provide a function to write the standard ebml header.
-fn start_tag(w: writer, tag_id: uint) {
-    #debug["Start tag %u", tag_id];
+impl writer for writer {
+    fn start_tag(tag_id: uint) {
+        #debug["Start tag %u", tag_id];
 
-    // Write the enum ID:
-    write_vu64(w.writer, tag_id as u64);
+        // Write the enum ID:
+        write_vuint(self.writer, tag_id);
 
-    // Write a placeholder four-byte size.
-    w.size_positions += [w.writer.tell()];
-    let zeroes: [u8] = [0u8, 0u8, 0u8, 0u8];
-    w.writer.write(zeroes);
-}
+        // Write a placeholder four-byte size.
+        self.size_positions += [self.writer.tell()];
+        let zeroes: [u8] = [0u8, 0u8, 0u8, 0u8];
+        self.writer.write(zeroes);
+    }
 
-fn end_tag(w: writer) {
-    let last_size_pos = vec::pop::<uint>(w.size_positions);
-    let cur_pos = w.writer.tell();
-    w.writer.seek(last_size_pos as int, io::seek_set);
-    let size = (cur_pos - last_size_pos - 4u);
-    write_sized_vu64(w.writer, size as u64, 4u);
-    w.writer.seek(cur_pos as int, io::seek_set);
+    fn end_tag() {
+        let last_size_pos = vec::pop::<uint>(self.size_positions);
+        let cur_pos = self.writer.tell();
+        self.writer.seek(last_size_pos as int, io::seek_set);
+        let size = (cur_pos - last_size_pos - 4u);
+        write_sized_vuint(self.writer, size, 4u);
+        self.writer.seek(cur_pos as int, io::seek_set);
 
-    #debug["End tag (size = %u)", size];
-}
+        #debug["End tag (size = %u)", size];
+    }
 
-impl writer_util for writer {
     fn wr_tag(tag_id: uint, blk: fn()) {
-        start_tag(self, tag_id);
+        self.start_tag(tag_id);
         blk();
-        end_tag(self);
+        self.end_tag();
     }
 
-    fn wr_vu64(id: u64) {
-        #debug["Write u64 0x%02x%02x",
-               (id >> 32u64) as uint,
-               (id & 0xFFFFFFFFu64) as uint];
-        write_vu64(self.writer, id);
+    fn wr_tagged_bytes(tag_id: uint, b: [u8]) {
+        write_vuint(self.writer, tag_id);
+        write_vuint(self.writer, vec::len(b));
+        self.writer.write(b);
+    }
+
+    fn wr_tagged_u64(tag_id: uint, v: u64) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v, 8u));
+    }
+
+    fn wr_tagged_u32(tag_id: uint, v: u32) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 4u));
+    }
+
+    fn wr_tagged_u16(tag_id: uint, v: u16) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 2u));
+    }
+
+    fn wr_tagged_u8(tag_id: uint, v: u8) {
+        self.wr_tagged_bytes(tag_id, [v]);
     }
 
-    fn wr_vuint(id: uint) {
-        #debug["Write uint: %u", id];
-        write_vu64(self.writer, id as u64);
+    fn wr_tagged_i64(tag_id: uint, v: i64) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 8u));
+    }
+
+    fn wr_tagged_i32(tag_id: uint, v: i32) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 4u));
+    }
+
+    fn wr_tagged_i16(tag_id: uint, v: i16) {
+        self.wr_tagged_bytes(tag_id, io::u64_to_be_bytes(v as u64, 2u));
+    }
+
+    fn wr_tagged_i8(tag_id: uint, v: i8) {
+        self.wr_tagged_bytes(tag_id, [v as u8]);
+    }
+
+    fn wr_tagged_str(tag_id: uint, v: str) {
+        // Lame: can't use str::as_bytes() here because the resulting
+        // vector is NULL-terminated.  Annoyingly, the underlying
+        // writer interface doesn't permit us to write a slice of a
+        // vector.  We need first-class slices, I think.
+
+        // str::as_bytes(v) {|b| self.wr_tagged_bytes(tag_id, b); }
+        self.wr_tagged_bytes(tag_id, str::bytes(v));
     }
 
     fn wr_bytes(b: [u8]) {
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 0fb000c8315..1efd91d54db 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -366,19 +366,41 @@ fn mk_file_writer(path: str, flags: [fileflag])
     }
 }
 
-fn uint_to_le_bytes(n: uint, size: uint) -> [u8] {
+fn u64_to_le_bytes(n: u64, size: uint) -> [u8] {
     let bytes: [u8] = [], i = size, n = n;
-    while i > 0u { bytes += [(n & 255u) as u8]; n >>= 8u; i -= 1u; }
+    while i > 0u {
+        bytes += [(n & 255_u64) as u8];
+        n >>= 8_u64;
+        i -= 1u;
+    }
     ret bytes;
 }
 
-fn uint_to_be_bytes(n: uint, size: uint) -> [u8] {
+fn u64_to_be_bytes(n: u64, size: uint) -> [u8] {
+    assert size <= 8u;
     let bytes: [u8] = [];
-    let i = (size - 1u) as int;
-    while i >= 0 { bytes += [(n >> ((i * 8) as uint) & 255u) as u8]; i -= 1; }
+    let i = size;
+    while i > 0u {
+        let shift = ((i - 1u) * 8u) as u64;
+        bytes += [(n >> shift) as u8];
+        i -= 1u;
+    }
     ret bytes;
 }
 
+fn u64_from_be_bytes(data: [u8], start: uint, size: uint) -> u64 {
+    let sz = size;
+    assert (sz <= 8u);
+    let val = 0_u64;
+    let pos = start;
+    while sz > 0u {
+        sz -= 1u;
+        val += (data[pos] as u64) << ((sz * 8u) as u64);
+        pos += 1u;
+    }
+    ret val;
+}
+
 impl writer_util for writer {
     fn write_char(ch: char) {
         if ch as uint < 128u {
@@ -393,14 +415,36 @@ impl writer_util for writer {
     fn write_uint(n: uint) { self.write(str::bytes(uint::to_str(n, 10u))); }
 
     fn write_le_uint(n: uint, size: uint) {
-        self.write(uint_to_le_bytes(n, size));
+        self.write(u64_to_le_bytes(n as u64, size));
     }
     fn write_le_int(n: int, size: uint) {
-        self.write(uint_to_le_bytes(n as uint, size));
+        self.write(u64_to_le_bytes(n as u64, size));
     }
+
     fn write_be_uint(n: uint, size: uint) {
-        self.write(uint_to_be_bytes(n, size));
+        self.write(u64_to_be_bytes(n as u64, size));
+    }
+    fn write_be_int(n: int, size: uint) {
+        self.write(u64_to_be_bytes(n as u64, size));
     }
+
+    fn write_be_u64(n: u64) { self.write(u64_to_be_bytes(n, 8u)); }
+    fn write_be_u32(n: u32) { self.write(u64_to_be_bytes(n as u64, 4u)); }
+    fn write_be_u16(n: u16) { self.write(u64_to_be_bytes(n as u64, 2u)); }
+
+    fn write_be_i64(n: i64) { self.write(u64_to_be_bytes(n as u64, 8u)); }
+    fn write_be_i32(n: i32) { self.write(u64_to_be_bytes(n as u64, 4u)); }
+    fn write_be_i16(n: i16) { self.write(u64_to_be_bytes(n as u64, 2u)); }
+
+    fn write_le_u64(n: u64) { self.write(u64_to_le_bytes(n, 8u)); }
+    fn write_le_u32(n: u32) { self.write(u64_to_le_bytes(n as u64, 4u)); }
+    fn write_le_u16(n: u16) { self.write(u64_to_le_bytes(n as u64, 2u)); }
+
+    fn write_le_i64(n: i64) { self.write(u64_to_le_bytes(n as u64, 8u)); }
+    fn write_le_i32(n: i32) { self.write(u64_to_le_bytes(n as u64, 4u)); }
+    fn write_le_i16(n: i16) { self.write(u64_to_le_bytes(n as u64, 2u)); }
+
+    fn write_u8(n: u8) { self.write([n]) }
 }
 
 fn file_writer(path: str, flags: [fileflag]) -> result::t<writer, str> {
diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs
index 1cc8cb529d8..c1c862cd386 100644
--- a/src/libstd/serialization.rs
+++ b/src/libstd/serialization.rs
@@ -5,15 +5,25 @@ Support code for serialization.
 */
 
 import list::list;
-import ebml::writer_util;
+import ebml::writer;
 
 iface serializer {
     // Primitive types:
     fn emit_nil();
+    fn emit_uint(v: uint);
     fn emit_u64(v: u64);
+    fn emit_u32(v: u32);
+    fn emit_u16(v: u16);
+    fn emit_u8(v: u8);
+    fn emit_int(v: int);
     fn emit_i64(v: i64);
+    fn emit_i32(v: i32);
+    fn emit_i16(v: i16);
+    fn emit_i8(v: i8);
     fn emit_bool(v: bool);
+    fn emit_float(v: float);
     fn emit_f64(v: f64);
+    fn emit_f32(v: f32);
     fn emit_str(v: str);
 
     // Compound types:
@@ -33,12 +43,28 @@ iface serializer {
 iface deserializer {
     // Primitive types:
     fn read_nil() -> ();
+
+    fn read_uint() -> uint;
     fn read_u64() -> u64;
+    fn read_u32() -> u32;
+    fn read_u16() -> u16;
+    fn read_u8() -> u8;
+
+    fn read_int() -> int;
     fn read_i64() -> i64;
+    fn read_i32() -> i32;
+    fn read_i16() -> i16;
+    fn read_i8() -> i8;
+
+
     fn read_bool() -> bool;
-    fn read_f64() -> f64;
+
     fn read_str() -> str;
 
+    fn read_f64() -> f64;
+    fn read_f32() -> f32;
+    fn read_float() -> float;
+
     // Compound types:
     fn read_enum<T:copy>(name: str, f: fn() -> T) -> T;
     fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T;
@@ -54,8 +80,11 @@ iface deserializer {
 }
 
 enum ebml_serializer_tag {
-    es_u64, es_i64, es_bool,
+    es_uint, es_u64, es_u32, es_u16, es_u8,
+    es_int, es_i64, es_i32, es_i16, es_i8,
+    es_bool,
     es_str,
+    es_f64, es_f32, es_float,
     es_enum, es_enum_vid, es_enum_body,
     es_vec, es_vec_len, es_vec_elt
 }
@@ -63,38 +92,54 @@ enum ebml_serializer_tag {
 impl of serializer for ebml::writer {
     fn emit_nil() {}
 
-    fn emit_num(tag: ebml_serializer_tag, v: u64) {
-        self.wr_tag(tag as uint) {|| self.wr_vu64(v) }
+    // used internally to emit things like the vector length and so on
+    fn _emit_tagged_uint(t: ebml_serializer_tag, v: uint) {
+        assert v <= 0xFFFF_FFFF_u;
+        self.wr_tagged_u32(t as uint, v as u32);
     }
 
-    fn emit_u64(v: u64) { self.emit_num(es_u64, v) }
-    fn emit_i64(v: i64) { self.emit_num(es_i64, v as u64) }
-    fn emit_bool(v: bool) { self.emit_num(es_bool, v as u64) }
+    fn emit_uint(v: uint) { self.wr_tagged_u64(es_uint as uint, v as u64); }
+    fn emit_u64(v: u64) { self.wr_tagged_u64(es_u64 as uint, v); }
+    fn emit_u32(v: u32) { self.wr_tagged_u32(es_u32 as uint, v); }
+    fn emit_u16(v: u16) { self.wr_tagged_u16(es_u16 as uint, v); }
+    fn emit_u8(v: u8)   { self.wr_tagged_u8 (es_u8  as uint, v); }
+
+    fn emit_int(v: int) { self.wr_tagged_i64(es_int as uint, v as i64); }
+    fn emit_i64(v: i64) { self.wr_tagged_i64(es_i64 as uint, v); }
+    fn emit_i32(v: i32) { self.wr_tagged_i32(es_i32 as uint, v); }
+    fn emit_i16(v: i16) { self.wr_tagged_i16(es_i16 as uint, v); }
+    fn emit_i8(v: i8)   { self.wr_tagged_i8 (es_i8  as uint, v); }
+
+    fn emit_bool(v: bool) { self.wr_tagged_u8(es_bool as uint, v as u8) }
+
     fn emit_f64(_v: f64) { fail "TODO"; }
-    fn emit_str(v: str) { self.wr_tag(es_str as uint) {|| self.wr_str(v) } }
+    fn emit_f32(_v: f32) { fail "TODO"; }
+    fn emit_float(_v: float) { fail "TODO"; }
+
+    fn emit_str(v: str) { self.wr_tagged_str(es_str as uint, v) }
 
     fn emit_enum(_name: str, f: fn()) {
-        self.wr_tag(es_enum as uint) {|| f() }
+        self.wr_tag(es_enum as uint, f)
     }
     fn emit_enum_variant(_v_name: str, v_id: uint, _cnt: uint, f: fn()) {
-        self.emit_num(es_enum_vid, v_id as u64);
-        self.wr_tag(es_enum_body as uint) {|| f() }
+        self._emit_tagged_uint(es_enum_vid, v_id);
+        self.wr_tag(es_enum_body as uint, f)
     }
     fn emit_enum_variant_arg(_idx: uint, f: fn()) { f() }
 
     fn emit_vec(len: uint, f: fn()) {
         self.wr_tag(es_vec as uint) {||
-            self.emit_num(es_vec_len, len as u64);
+            self._emit_tagged_uint(es_vec_len, len);
             f()
         }
     }
 
     fn emit_vec_elt(_idx: uint, f: fn()) {
-        self.wr_tag(es_vec_elt as uint) {|| f() }
+        self.wr_tag(es_vec_elt as uint, f)
     }
 
     fn emit_vec_elt(_idx: uint, f: fn()) {
-        self.wr_tag(es_vec_elt as uint) {|| f() }
+        self.wr_tag(es_vec_elt as uint, f)
     }
 
     fn emit_box(f: fn()) { f() }
@@ -145,18 +190,45 @@ impl of deserializer for ebml_deserializer {
         ret r;
     }
 
-    fn next_u64(exp_tag: ebml_serializer_tag) -> u64 {
-        let r = ebml::doc_as_vu64(self.next_doc(exp_tag));
-        #debug["next_u64 exp_tag=%? result=%?", exp_tag, r];
-        ret r;
+    fn _next_uint(exp_tag: ebml_serializer_tag) -> uint {
+        let r = ebml::doc_as_u32(self.next_doc(exp_tag));
+        #debug["_next_uint exp_tag=%? result=%?", exp_tag, r];
+        ret r as uint;
     }
 
     fn read_nil() -> () { () }
-    fn read_u64() -> u64 { self.next_u64(es_u64) }
-    fn read_i64() -> i64 { self.next_u64(es_i64) as i64 }
-    fn read_bool() -> bool { self.next_u64(es_bool) as bool }
-    fn read_f64() -> f64 { fail "Float"; }
-    fn read_str() -> str { ebml::doc_str(self.next_doc(es_str)) }
+
+    fn read_u64() -> u64 { ebml::doc_as_u64(self.next_doc(es_u64)) }
+    fn read_u32() -> u32 { ebml::doc_as_u32(self.next_doc(es_u32)) }
+    fn read_u16() -> u16 { ebml::doc_as_u16(self.next_doc(es_u16)) }
+    fn read_u8 () -> u8  { ebml::doc_as_u8 (self.next_doc(es_u8 )) }
+    fn read_uint() -> uint {
+        let v = ebml::doc_as_u64(self.next_doc(es_uint));
+        if v > (uint::max_value as u64) {
+            fail #fmt["uint %? too large for this architecture", v];
+        }
+        ret v as uint;
+    }
+
+    fn read_i64() -> i64 { ebml::doc_as_u64(self.next_doc(es_i64)) as i64 }
+    fn read_i32() -> i32 { ebml::doc_as_u32(self.next_doc(es_i32)) as i32 }
+    fn read_i16() -> i16 { ebml::doc_as_u16(self.next_doc(es_i16)) as i16 }
+    fn read_i8 () -> i8  { ebml::doc_as_u8 (self.next_doc(es_i8 )) as i8  }
+    fn read_int() -> int {
+        let v = ebml::doc_as_u64(self.next_doc(es_int)) as i64;
+        if v > (int::max_value as i64) || v < (int::min_value as i64) {
+            fail #fmt["int %? out of range for this architecture", v];
+        }
+        ret v as int;
+    }
+
+    fn read_bool() -> bool { ebml::doc_as_u8(self.next_doc(es_bool)) as bool }
+
+    fn read_f64() -> f64 { fail "read_f64()"; }
+    fn read_f32() -> f32 { fail "read_f32()"; }
+    fn read_float() -> float { fail "read_float()"; }
+
+    fn read_str() -> str { ebml::doc_as_str(self.next_doc(es_str)) }
 
     // Compound types:
     fn read_enum<T:copy>(_name: str, f: fn() -> T) -> T {
@@ -164,7 +236,7 @@ impl of deserializer for ebml_deserializer {
     }
 
     fn read_enum_variant<T:copy>(f: fn(uint) -> T) -> T {
-        let idx = self.next_u64(es_enum_vid) as uint;
+        let idx = self._next_uint(es_enum_vid);
         self.push_doc(self.next_doc(es_enum_body)) {||
             f(idx)
         }
@@ -176,7 +248,7 @@ impl of deserializer for ebml_deserializer {
 
     fn read_vec<T:copy>(f: fn(uint) -> T) -> T {
         self.push_doc(self.next_doc(es_vec)) {||
-            let len = self.next_u64(es_vec_len) as uint;
+            let len = self._next_uint(es_vec_len);
             f(len)
         }
     }
@@ -211,6 +283,36 @@ impl of deserializer for ebml_deserializer {
 }
 
 // ___________________________________________________________________________
+// Helper routines
+//
+// These should eventually be coded as traits.
+
+impl serializer_helpers<S: serializer> for S {
+    fn emit_from_vec<T>(v: [T], f: fn(T)) {
+        self.emit_vec(vec::len(v)) {||
+            vec::iteri(v) {|i,e|
+                self.emit_vec_elt(i) {||
+                    f(e)
+                }
+            }
+        }
+    }
+}
+
+impl deserializer_helpers<D: deserializer> for D {
+    fn read_to_vec<T>(f: fn() -> T) -> [T] {
+        self.read_vec {|len|
+            let v = [];
+            vec::reserve(v, len);
+            uint::range(0u, len) {|i|
+                self.read_vec_elt(i) {|| v += [f()] }
+            }
+            v
+        }
+    }
+}
+
+// ___________________________________________________________________________
 // Testing
 
 #[test]
@@ -257,7 +359,7 @@ fn test_option_int() {
     fn test_v(v: option<int>) {
         #debug["v == %?", v];
         let mbuf = io::mk_mem_buffer();
-        let ebml_w = ebml::create_writer(io::mem_buffer_writer(mbuf));
+        let ebml_w = ebml::mk_writer(io::mem_buffer_writer(mbuf));
         serialize_0(ebml_w, v);
         let ebml_doc = ebml::new_doc(@io::mem_buffer_buf(mbuf));
         let deser = mk_ebml_deserializer(ebml_doc);
diff --git a/src/libstd/std.rc b/src/libstd/std.rc
index 695a45f9be7..478dbb69513 100644
--- a/src/libstd/std.rc
+++ b/src/libstd/std.rc
@@ -12,7 +12,7 @@ export c_vec, four, tri, util;
 export bitv, deque, fun_treemap, list, map, smallintmap, sort, treemap, ufind;
 export rope;
 export ebml, dbg, getopts, json, rand, sha1, term, time;
-export test, tempfile;
+export test, tempfile, serialization;
 // FIXME: generic_os and os_fs shouldn't be exported
 export generic_os, os, os_fs;
 
@@ -111,5 +111,4 @@ mod os_fs;
 // indent-tabs-mode: nil
 // c-basic-offset: 4
 // buffer-file-coding-system: utf-8-unix
-// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
 // End:
diff --git a/src/serializer/serializer.rs b/src/serializer/serializer.rs
index 5604ff2a883..90db74c4039 100644
--- a/src/serializer/serializer.rs
+++ b/src/serializer/serializer.rs
@@ -56,7 +56,8 @@ type serialize_ctx = {
     crate: @ast::crate,
     tcx: ty::ctxt,
 
-    tyfns: hashmap<ty::t, str>,
+    serialize_tyfns: hashmap<ty::t, str>,
+    deserialize_tyfns: hashmap<ty::t, str>,
     mutable item_fns: [ast_item],
     mutable constants: [str]
 
@@ -84,19 +85,10 @@ fn lookup(_mod: ast::_mod, idx: uint, names: [str]) -> @ast::item {
 }
 
 impl serialize_ctx for serialize_ctx {
-    // fn session() -> parser::parse_sess { self.psess }
-
     fn add_item(item: ast_item) {
         self.item_fns += [item];
     }
 
-    fn mk_serialize_named_item_fn(name: str) -> str {
-        let names = str::split_str(name, "::");
-        let item = lookup(self.crate.node.module, 0u, names);
-        let def_id = {crate: ast::local_crate, node: item.id};
-        self.mk_serialize_item_fn(def_id, [])
-    }
-
     fn tp_map(ty_params: [ast::ty_param], tps: [ty::t]) -> tp_map {
         assert vec::len(tps) == vec::len(ty_params);
         let tps_map = new_int_hash();
@@ -123,10 +115,51 @@ impl serialize_ctx for serialize_ctx {
         };
     }
 
-    fn mk_serialize_item_fn(id: ast::def_id,
-                            tps: [ty::t]) -> str {
-        let item_ty = self.instantiate(id, tps);
-        self.mk_serialize_ty_fn(item_ty)
+    fn memoize(map: hashmap<ty::t, str>, base_name: str,
+               ty0: ty::t, mk_fn: fn(str)) -> str {
+        // check for existing function
+        alt map.find(ty0) {
+          some(name) { ret name; }
+          none { /* fallthrough */ }
+        }
+
+        // define the name and insert into the hashtable
+        // in case of recursive calls:
+        let id = map.size();
+        let name = #fmt["%s_%u", base_name, id];
+        map.insert(ty0, name);
+        mk_fn(name);
+        ret name;
+    }
+
+    fn exec_named_item_fn(name: str, f: fn(ty::t) -> str) -> str {
+        let names = str::split_str(name, "::");
+        let item = lookup(self.crate.node.module, 0u, names);
+        let def_id = {crate: ast::local_crate, node: item.id};
+        let item_ty = self.instantiate(def_id, []);
+        f(item_ty)
+    }
+}
+
+impl serialize_methods for serialize_ctx {
+    // fn session() -> parser::parse_sess { self.psess }
+
+    fn mk_serialize_named_item_fn(name: str) -> str {
+        self.exec_named_item_fn(name) {|item_ty|
+            let fname = self.mk_serialize_ty_fn(item_ty);
+
+            let ty_str = ppaux::ty_to_str(self.tcx, item_ty);
+            check str::is_not_empty("::");
+            let namep = str::replace(name, "::", "_");
+            let item = #fmt["fn serialize_%s\
+                                 <S:std::serialization::serializer>\n\
+                                 (s: S, v: %s) {\n\
+                                   %s(s, v);\n\
+                                 }", namep, ty_str, fname];
+            self.add_item(item);
+
+            fname
+        }
     }
 
     fn blk(stmts: [ast_stmt]) -> ast_blk {
@@ -145,59 +178,75 @@ impl serialize_ctx for serialize_ctx {
     // Returns an AST fragment that names this function.
     fn serialize_ty(ty0: ty::t, v: ast_expr) -> ast_expr {
         let fname = self.mk_serialize_ty_fn(ty0);
-        #fmt["%s(cx, %s)", fname, v]
+        let ty0_str = ppaux::ty_to_str(self.tcx, ty0);
+        #fmt["/*%s*/ %s(s, %s)", ty0_str, fname, v]
     }
 
     fn mk_serialize_ty_fn(ty0: ty::t) -> str {
-        // check for existing function
-        alt self.tyfns.find(ty0) {
-          some(name) { ret name; }
-          none { /* fallthrough */ }
+        self.memoize(self.serialize_tyfns, "serialize", ty0) {|name|
+            self.mk_serialize_ty_fn0(ty0, name)
         }
+    }
 
-        // define the name and insert into the hashtable
-        // in case of recursive calls:
-        let id = self.tyfns.size();
+    fn mk_serialize_ty_fn0(ty0: ty::t, name: str) {
         let ty0_str = ppaux::ty_to_str(self.tcx, ty0);
-        #debug["ty0_str = %s / ty0 = %?", ty0_str, ty0];
-        let name = #fmt["serialize_%u /*%s*/", id, ty0_str];
-        self.tyfns.insert(ty0, name);
         let v = "v";
 
         let body_node = alt ty::get(ty0).struct {
           ty::ty_nil | ty::ty_bot { "()" }
-          ty::ty_int(_) { #fmt["s.emit_i64(%s as i64)", v] }
-          ty::ty_uint(_) { #fmt["s.emit_u64(%s as u64)", v] }
-          ty::ty_float(_) { #fmt["s.emit_f64(%s as f64)", v] }
-          ty::ty_bool { #fmt["s.emit_bool(%s)", v] }
-          ty::ty_str { #fmt["s.emit_str(%s)", v] }
+
+          ty::ty_int(ast::ty_i)   { #fmt["\ns.emit_int(%s)\n", v] }
+          ty::ty_int(ast::ty_i64) { #fmt["\ns.emit_i64(%s)\n", v] }
+          ty::ty_int(ast::ty_i32) { #fmt["\ns.emit_i32(%s)\n", v] }
+          ty::ty_int(ast::ty_i16) { #fmt["\ns.emit_i16(%s)\n", v] }
+          ty::ty_int(ast::ty_i8)  { #fmt["\ns.emit_i8(%s)\n", v]  }
+
+          ty::ty_int(ast::ty_char) { #fmt["\ns.emit_i8(%s as i8)\n", v] }
+
+          ty::ty_uint(ast::ty_u)   { #fmt["\ns.emit_uint(%s)\n", v] }
+          ty::ty_uint(ast::ty_u64) { #fmt["\ns.emit_u64(%s)\n", v] }
+          ty::ty_uint(ast::ty_u32) { #fmt["\ns.emit_u32(%s)\n", v] }
+          ty::ty_uint(ast::ty_u16) { #fmt["\ns.emit_u16(%s)\n", v] }
+          ty::ty_uint(ast::ty_u8)  { #fmt["\ns.emit_u8(%s)\n", v]  }
+
+          ty::ty_float(ast::ty_f64) { #fmt["\ns.emit_f64(%s)\n", v] }
+          ty::ty_float(ast::ty_f32) { #fmt["\ns.emit_f32(%s)\n", v] }
+          ty::ty_float(ast::ty_f)   { #fmt["\ns.emit_float(%s)\n", v] }
+
+          ty::ty_bool { #fmt["\ns.emit_bool(%s)\n", v] }
+
+          ty::ty_str { #fmt["\ns.emit_str(%s)\n", v] }
+
           ty::ty_enum(def_id, tps) { self.serialize_enum(v, def_id, tps) }
           ty::ty_box(mt) {
-            let s = self.serialize_ty(mt.ty, #fmt["*%s", v]);
-            #fmt["s.emit_box({||%s})", s]
+            let s = self.serialize_ty(mt.ty, #fmt["\n*%s\n", v]);
+            #fmt["\ns.emit_box({||%s})\n", s]
           }
           ty::ty_uniq(mt) {
-            let s = self.serialize_ty(mt.ty, #fmt["*%s", v]);
-            #fmt["s.emit_uniq({||%s})", s]
+            let s = self.serialize_ty(mt.ty, #fmt["\n*%s\n", v]);
+            #fmt["\ns.emit_uniq({||%s})\n", s]
           }
           ty::ty_vec(mt) {
-            let selem = self.serialize_ty(mt.ty, "i");
-            #fmt["s.emit_vec(vec::len(v), {|| \
-                  uint::range(0, vec::len(v), {|i| \
-                  s.emit_vec_elt(i, {||\
-                  %s;\
-                  })})})", selem]
+            let selem = self.serialize_ty(mt.ty, "e");
+            #fmt["\ns.emit_vec(vec::len(v), {||\n\
+                    vec::iteri(v, {|i, e|\n\
+                      s.emit_vec_elt(i, {||\n\
+                          %s\n\
+                  })})})\n", selem]
           }
           ty::ty_class(_, _) {
             fail "TODO--implement class";
           }
           ty::ty_rec(fields) {
-            let stmts = vec::map(fields) {|field|
+            let stmts = vec::init_fn(vec::len(fields)) {|i|
+                let field = fields[i];
                 let f_name = field.ident;
                 let f_ty = field.mt.ty;
-                self.serialize_ty(f_ty, #fmt["%s.%s", v, f_name])
+                let efld = self.serialize_ty(f_ty, #fmt["\n%s.%s\n", v, f_name]);
+                #fmt["\ns.emit_rec_field(\"%s\", %uu, {||%s})\n",
+                     f_name, i, efld]
             };
-            #fmt["s.emit_rec({||%s})", self.blk_expr(stmts)]
+            #fmt["\ns.emit_rec({||%s})\n", self.blk_expr(stmts)]
           }
           ty::ty_tup(tys) {
             let (pat, stmts) = self.serialize_arm("", "emit_tup_elt", tys);
@@ -219,12 +268,13 @@ impl serialize_ctx for serialize_ctx {
           }
         };
 
-        let item = #fmt["fn %s<S:std::serialization::serializer>\
-                            (s: S, v: %s) {\
-                             %s;\
-                         }", name, ty0_str, body_node];
+        let item = #fmt["/*%s*/ fn %s\n\
+                         <S:std::serialization::serializer>\n\
+                            (s: S,\n\
+                            v: %s) {\n\
+                             %s;\n\
+                         }", ty0_str, name, ty0_str, body_node];
         self.add_item(item);
-        ret name;
     }
 
     fn serialize_enum(v: ast_expr,
@@ -249,19 +299,19 @@ impl serialize_ctx for serialize_ctx {
             let v_id = idx;
             idx += 1u;
 
-            #fmt["%s { \
-                    s.emit_enum_variant(\"%s\", %uu, %uu) {||\
-                      %s \
-                    } \
+            #fmt["%s {\n\
+                    s.emit_enum_variant(\"%s\", %uu, %uu, {||\n\
+                      %s\n\
+                    })\n\
                   }", v_pat, v_path, v_id, n_args, self.blk(stmts)]
         };
 
         let enum_name = ast_map::path_to_str(ty::item_path(self.tcx, id));
-        #fmt["s.emit_enum(\"%s\") {||\
-                alt %s { \
-                  %s \
-                }\
-              }", enum_name, v, str::connect(arms, "\n")]
+        #fmt["\ns.emit_enum(\"%s\", {||\n\
+                alt %s {\n\
+                  %s\n\
+                }\n\
+              })\n", enum_name, v, str::connect(arms, "\n")]
     }
 
     fn serialize_arm(v_path: str, emit_fn: str, args: [ty::t])
@@ -269,17 +319,177 @@ impl serialize_ctx for serialize_ctx {
         let n_args = vec::len(args);
         let arg_nms = vec::init_fn(n_args) {|i| #fmt["v%u", i] };
         let v_pat =
-            #fmt["%s(%s)", v_path, str::connect(arg_nms, ", ")];
+            #fmt["\n%s(%s)\n", v_path, str::connect(arg_nms, ",")];
         let stmts = vec::init_fn(n_args) {|i|
             let arg_ty = args[i];
             let serialize_expr =
                 self.serialize_ty(arg_ty, arg_nms[i]);
-            #fmt["s.%s(%uu, {|| %s })", emit_fn, i, serialize_expr]
+            #fmt["\ns.%s(%uu, {||\n%s\n})\n", emit_fn, i, serialize_expr]
         };
         (v_pat, stmts)
     }
 }
 
+impl deserialize_methods for serialize_ctx {
+    fn mk_deserialize_named_item_fn(name: str) -> str {
+        self.exec_named_item_fn(name) {|item_ty|
+            let fname = self.mk_deserialize_ty_fn(item_ty);
+
+            let ty_str = ppaux::ty_to_str(self.tcx, item_ty);
+            check str::is_not_empty("::");
+            let namep = str::replace(name, "::", "_");
+            let item = #fmt["fn deserialize_%s\
+                                 <S:std::serialization::deserializer>\n\
+                                 (s: S) -> %s {\n\
+                                   %s(s)\
+                                 }", namep, ty_str, fname];
+            self.add_item(item);
+
+            fname
+        }
+    }
+
+    // Generates a function to serialize the given type.
+    // Returns an AST fragment that names this function.
+    fn deserialize_ty(ty0: ty::t) -> ast_expr {
+        let fname = self.mk_deserialize_ty_fn(ty0);
+        let ty0_str = ppaux::ty_to_str(self.tcx, ty0);
+        #fmt["\n/*%s*/ %s(s)\n", ty0_str, fname]
+    }
+
+    fn mk_deserialize_ty_fn(ty0: ty::t) -> str {
+        self.memoize(self.deserialize_tyfns, "deserialize", ty0) {|name|
+            self.mk_deserialize_ty_fn0(ty0, name)
+        }
+    }
+
+    fn mk_deserialize_ty_fn0(ty0: ty::t, name: str) {
+        let ty0_str = ppaux::ty_to_str(self.tcx, ty0);
+        let body_node = alt ty::get(ty0).struct {
+          ty::ty_nil | ty::ty_bot { "()" }
+
+          ty::ty_int(ast::ty_i)   { #fmt["s.read_int()"] }
+          ty::ty_int(ast::ty_i64) { #fmt["s.read_i64()"] }
+          ty::ty_int(ast::ty_i32) { #fmt["s.read_i32()"] }
+          ty::ty_int(ast::ty_i16) { #fmt["s.read_i16()"] }
+          ty::ty_int(ast::ty_i8)  { #fmt["s.read_i8()"]  }
+
+          ty::ty_int(ast::ty_char) { #fmt["s.read_char()"] }
+
+          ty::ty_uint(ast::ty_u)   { #fmt["s.read_uint()"] }
+          ty::ty_uint(ast::ty_u64) { #fmt["s.read_u64()"] }
+          ty::ty_uint(ast::ty_u32) { #fmt["s.read_u32()"] }
+          ty::ty_uint(ast::ty_u16) { #fmt["s.read_u16()"] }
+          ty::ty_uint(ast::ty_u8)  { #fmt["s.read_u8()"]  }
+
+          ty::ty_float(ast::ty_f64) { #fmt["s.read_f64()"] }
+          ty::ty_float(ast::ty_f32) { #fmt["s.read_f32()"] }
+          ty::ty_float(ast::ty_f)   { #fmt["s.read_float()"] }
+
+          ty::ty_bool { #fmt["s.read_bool()"] }
+
+          ty::ty_str { #fmt["s.read_str()"] }
+
+          ty::ty_enum(def_id, tps) { self.deserialize_enum(def_id, tps) }
+          ty::ty_box(mt) {
+            let s = self.deserialize_ty(mt.ty);
+            #fmt["\ns.read_box({||@%s})\n", s]
+          }
+          ty::ty_uniq(mt) {
+            let s = self.deserialize_ty(mt.ty);
+            #fmt["\ns.read_uniq({||~%s})\n", s]
+          }
+          ty::ty_vec(mt) {
+            let selem = self.deserialize_ty(mt.ty);
+            #fmt["s.read_vec({|len|\n\
+                    vec::init_fn(len, {|i|\n\
+                      s.read_vec_elt(i, {||\n\
+                        %s\n\
+                  })})})", selem]
+          }
+          ty::ty_class(_, _) {
+            fail "TODO--implement class";
+          }
+          ty::ty_rec(fields) {
+            let i = 0u;
+            let flds = vec::map(fields) {|field|
+                let f_name = field.ident;
+                let f_ty = field.mt.ty;
+                let rfld = self.deserialize_ty(f_ty);
+                let idx = i;
+                i += 1u;
+                #fmt["\n%s: s.read_rec_field(\"%s\", %uu, {||\n%s\n})\n",
+                     f_name, f_name, idx, rfld]
+            };
+            #fmt["\ns.read_rec({||{\n%s\n}})\n", str::connect(flds, ",")]
+          }
+          ty::ty_tup(tys) {
+            let rexpr = self.deserialize_arm("", "read_tup_elt", tys);
+            #fmt["\ns.read_tup(%uu, {||\n%s\n})\n", vec::len(tys), rexpr]
+          }
+          ty::ty_constr(t, _) {
+            self.deserialize_ty(t)
+          }
+          ty::ty_ptr(_) |
+          ty::ty_fn(_) |
+          ty::ty_iface(_, _) |
+          ty::ty_res(_, _, _) |
+          ty::ty_var(_) | ty::ty_param(_, _) |
+          ty::ty_self(_) | ty::ty_type | ty::ty_send_type |
+          ty::ty_opaque_closure_ptr(_) | ty::ty_opaque_box {
+            fail #fmt["Unhandled type %s", ty0_str]
+          }
+        };
+
+        let item = #fmt["/*%s*/\n\
+                         fn %s\n\
+                         <S:std::serialization::deserializer>(s: S)\n\
+                         -> %s {\n\
+                             %s\n\
+                         }", ty0_str, name, ty0_str, body_node];
+        self.add_item(item);
+    }
+
+    fn deserialize_enum(id: ast::def_id,
+                        tps: [ty::t]) -> ast_expr {
+        let variants = ty::substd_enum_variants(self.tcx, id, tps);
+
+        let arms = vec::init_fn(vec::len(variants)) {|v_id|
+            let variant = variants[v_id];
+            let item_path = ty::item_path(self.tcx, variant.id);
+            let v_path = ast_map::path_to_str(item_path);
+            let n_args = vec::len(variant.args);
+            let rexpr = {
+                if n_args == 0u {
+                    #fmt["\n%s\n", v_path]
+                } else {
+                    self.deserialize_arm(v_path, "read_enum_variant_arg",
+                                         variant.args)
+                }
+            };
+
+            #fmt["\n%uu { %s }\n", v_id, rexpr]
+        };
+
+        let enum_name = ast_map::path_to_str(ty::item_path(self.tcx, id));
+        #fmt["s.read_enum(\"%s\", {||\n\
+                s.read_enum_variant({|v_id|\n\
+                  alt check v_id {\n\
+                    %s\n\
+                  }\n\
+                })})", enum_name, str::connect(arms, "\n")]
+    }
+
+    fn deserialize_arm(v_path: str, read_fn: str, args: [ty::t])
+        -> ast_expr {
+        let exprs = vec::init_fn(vec::len(args)) {|i|
+            let rexpr = self.deserialize_ty(args[i]);
+            #fmt["\ns.%s(%uu, {||%s})\n", read_fn, i, rexpr]
+        };
+        #fmt["\n%s(%s)\n", v_path, str::connect(exprs, ",")]
+    }
+}
+
 fn main(argv: [str]) {
     let {crate, tcx, roots} = parse(argv);
     let sctx: serialize_ctx = {
@@ -294,13 +504,15 @@ fn main(argv: [str]) {
         // };
         {crate: crate,
          tcx: tcx,
-         tyfns: ty::new_ty_hash::<str>(),
+         serialize_tyfns: ty::new_ty_hash::<str>(),
+         deserialize_tyfns: ty::new_ty_hash::<str>(),
          mutable item_fns: [],
          mutable constants: []}
     };
 
     vec::iter(roots) {|root|
         sctx.mk_serialize_named_item_fn(root);
+        sctx.mk_deserialize_named_item_fn(root);
     }
 
     let stdout = io::stdout();