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

7 files changed, 9714 insertions, 681 deletions

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(']');