switch over to using new serialize/deserialize code

2 files changed, 118 insertions, 120 deletions

diff --git a/src/rustc/syntax/ast.rs b/src/rustc/syntax/ast.rs
index a925514b8fb..43b0d5e0391 100644
--- a/src/rustc/syntax/ast.rs
+++ b/src/rustc/syntax/ast.rs
@@ -26,45 +26,45 @@ fn deserialize_span<D>(_d: D) -> span {
     ast_util::dummy_sp()
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type spanned<T> = {node: T, span: span};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type ident = str;
 
 // Functions may or may not have names.
-/*#[auto_serialize]*/
+#[auto_serialize]
 type fn_ident = option<ident>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type path_ = {global: bool, idents: [ident], types: [@ty]};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type path = spanned<path_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type crate_num = int;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type node_id = int;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type def_id = {crate: crate_num, node: node_id};
 
 const local_crate: crate_num = 0;
 const crate_node_id: node_id = 0;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum ty_param_bound {
     bound_copy,
     bound_send,
     bound_iface(@ty),
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type ty_param = {ident: ident, id: node_id, bounds: @[ty_param_bound]};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum def {
     def_fn(def_id, purity),
     def_self(node_id),
@@ -119,30 +119,30 @@ enum crate_directive_ {
 
 type crate_directive = spanned<crate_directive_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type meta_item = spanned<meta_item_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum meta_item_ {
     meta_word(ident),
     meta_list(ident, [@meta_item]),
     meta_name_value(ident, lit),
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type blk = spanned<blk_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type blk_ = {view_items: [@view_item], stmts: [@stmt], expr: option<@expr>,
              id: node_id, rules: blk_check_mode};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type pat = {id: node_id, node: pat_, span: span};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type field_pat = {ident: ident, pat: @pat};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum pat_ {
     pat_wild,
     // A pat_ident may either be a new bound variable,
@@ -162,10 +162,10 @@ enum pat_ {
     pat_range(@expr, @expr),
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum mutability { m_mutbl, m_imm, m_const, }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum proto {
     proto_bare,    // native fn
     proto_any,     // fn
@@ -181,7 +181,7 @@ pure fn is_blockish(p: ast::proto) -> bool {
     }
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum binop {
     add,
     subtract,
@@ -204,7 +204,7 @@ enum binop {
     gt,
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum unop {
     box(mutability),
     uniq(mutability),
@@ -213,23 +213,23 @@ enum unop {
 
 // Generally, after typeck you can get the inferred value
 // using ty::resolved_T(...).
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum inferable<T> {
     expl(T), infer(node_id)
 }
 
 // "resolved" mode: the real modes.
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum rmode { by_ref, by_val, by_mutbl_ref, by_move, by_copy }
 
 // inferable mode.
-/*#[auto_serialize]*/
+#[auto_serialize]
 type mode = inferable<rmode>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type stmt = spanned<stmt_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum stmt_ {
     stmt_decl(@decl, node_id),
 
@@ -240,48 +240,48 @@ enum stmt_ {
     stmt_semi(@expr, node_id),
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum init_op { init_assign, init_move, }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type initializer = {op: init_op, expr: @expr};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type local_ =  // FIXME: should really be a refinement on pat
     {is_mutbl: bool, ty: @ty, pat: @pat,
      init: option<initializer>, id: node_id};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type local = spanned<local_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type decl = spanned<decl_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum decl_ { decl_local([@local]), decl_item(@item), }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type arm = {pats: [@pat], guard: option<@expr>, body: blk};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type field_ = {mutbl: mutability, ident: ident, expr: @expr};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type field = spanned<field_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum blk_check_mode { default_blk, unchecked_blk, unsafe_blk, }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum expr_check_mode { claimed_expr, checked_expr, }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type expr = {id: node_id, node: expr_, span: span};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum alt_mode { alt_check, alt_exhaustive, }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum expr_ {
     expr_vec([@expr], mutability),
     expr_rec([field], option<@expr>),
@@ -337,14 +337,14 @@ enum expr_ {
     expr_mac(mac),
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type capture_item = {
     id: int,
     name: ident, // Currently, can only capture a local var.
     span: span
 };
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type capture_clause = {
     copies: [@capture_item],
     moves: [@capture_item]
@@ -359,19 +359,19 @@ enum blk_sort {
 }
 */
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type mac = spanned<mac_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type mac_arg = option<@expr>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type mac_body_ = {span: span};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type mac_body = option<mac_body_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum mac_ {
     mac_invoc(@path, mac_arg, mac_body),
     mac_embed_type(@ty),
@@ -382,10 +382,10 @@ enum mac_ {
     mac_var(uint)
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type lit = spanned<lit_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum lit_ {
     lit_str(str),
     lit_int(i64, int_ty),
@@ -397,33 +397,33 @@ enum lit_ {
 
 // NB: If you change this, you'll probably want to change the corresponding
 // type structure in middle/ty.rs as well.
-/*#[auto_serialize]*/
+#[auto_serialize]
 type mt = {ty: @ty, mutbl: mutability};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type ty_field_ = {ident: ident, mt: mt};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type ty_field = spanned<ty_field_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type ty_method = {ident: ident, attrs: [attribute],
                   decl: fn_decl, tps: [ty_param], span: span};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum int_ty { ty_i, ty_char, ty_i8, ty_i16, ty_i32, ty_i64, }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum uint_ty { ty_u, ty_u8, ty_u16, ty_u32, ty_u64, }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum float_ty { ty_f, ty_f32, ty_f64, }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type ty = {id: node_id, node: ty_, span: span};
 
 // Not represented directly in the AST, referred to by name through a ty_path.
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum prim_ty {
     ty_int(int_ty),
     ty_uint(uint_ty),
@@ -432,17 +432,17 @@ enum prim_ty {
     ty_bool,
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type region = {id: node_id, node: region_};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum region_ {
     re_inferred,
     re_named(ident),
     re_self
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum ty_ {
     ty_nil,
     ty_bot, /* bottom type */
@@ -472,19 +472,19 @@ so that the typestate pass doesn't have to map a function name onto its decl.
 So, the constr_arg type is parameterized: it's instantiated with uint for
 declarations, and ident for uses.
 */
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum constr_arg_general_<T> { carg_base, carg_ident(T), carg_lit(@lit), }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type fn_constr_arg = constr_arg_general_<uint>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type sp_constr_arg<T> = spanned<constr_arg_general_<T>>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type ty_constr_arg = sp_constr_arg<@path>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type constr_arg = spanned<fn_constr_arg>;
 
 // Constrained types' args are parameterized by paths, since
@@ -492,34 +492,34 @@ type constr_arg = spanned<fn_constr_arg>;
 // The implicit root of such path, in the constraint-list for a
 // constrained type, is * (referring to the base record)
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type constr_general_<ARG, ID> =
     {path: @path, args: [@spanned<constr_arg_general_<ARG>>], id: ID};
 
 // In the front end, constraints have a node ID attached.
 // Typeck turns this to a def_id, using the output of resolve.
-/*#[auto_serialize]*/
+#[auto_serialize]
 type constr_general<ARG> = spanned<constr_general_<ARG, node_id>>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type constr_ = constr_general_<uint, node_id>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type constr = spanned<constr_general_<uint, node_id>>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type ty_constr_ = constr_general_<@path, node_id>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type ty_constr = spanned<ty_constr_>;
 
 /* The parser generates ast::constrs; resolve generates
  a mapping from each function to a list of ty::constr_defs,
  corresponding to these. */
-/*#[auto_serialize]*/
+#[auto_serialize]
 type arg = {mode: mode, ty: @ty, ident: ident, id: node_id};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type fn_decl =
     {inputs: [arg],
      output: @ty,
@@ -527,7 +527,7 @@ type fn_decl =
      cf: ret_style,
      constraints: [@constr]};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum purity {
     pure_fn, // declared with "pure fn"
     unsafe_fn, // declared with "unsafe fn"
@@ -535,58 +535,58 @@ enum purity {
     crust_fn, // declared with "crust fn"
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum ret_style {
     noreturn, // functions with return type _|_ that always
               // raise an error or exit (i.e. never return to the caller)
     return_val, // everything else
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type method = {ident: ident, attrs: [attribute],
                tps: [ty_param], decl: fn_decl, body: blk,
                id: node_id, span: span, self_id: node_id};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type _mod = {view_items: [@view_item], items: [@item]};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum native_abi {
     native_abi_rust_intrinsic,
     native_abi_cdecl,
     native_abi_stdcall,
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type native_mod =
     {view_items: [@view_item],
      items: [@native_item]};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type variant_arg = {ty: @ty, id: node_id};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type variant_ = {name: ident, attrs: [attribute], args: [variant_arg],
                  id: node_id, disr_expr: option<@expr>};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type variant = spanned<variant_>;
 
 // FIXME: May want to just use path here, which would allow things like
 // 'import ::foo'
-/*#[auto_serialize]*/
+#[auto_serialize]
 type simple_path = [ident];
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type path_list_ident_ = {name: ident, id: node_id};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type path_list_ident = spanned<path_list_ident_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type view_path = spanned<view_path_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum view_path_ {
 
     // quux = foo::bar::baz
@@ -603,10 +603,10 @@ enum view_path_ {
     view_path_list(@simple_path, [path_list_ident], node_id)
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type view_item = spanned<view_item_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum view_item_ {
     view_item_use(ident, [@meta_item], node_id),
     view_item_import([@view_path]),
@@ -614,23 +614,23 @@ enum view_item_ {
 }
 
 // Meta-data associated with an item
-/*#[auto_serialize]*/
+#[auto_serialize]
 type attribute = spanned<attribute_>;
 
 // Distinguishes between attributes that decorate items and attributes that
 // are contained as statements within items. These two cases need to be
 // distinguished for pretty-printing.
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum attr_style { attr_outer, attr_inner, }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type attribute_ = {style: attr_style, value: meta_item};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type item = {ident: ident, attrs: [attribute],
              id: node_id, node: item_, span: span};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum item_ {
     item_const(@ty, @expr),
     item_fn(fn_decl, [ty_param], blk),
@@ -650,13 +650,13 @@ enum item_ {
               @ty /* self */, [@method]),
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type class_item_ = {privacy: privacy, decl: class_member};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type class_item = spanned<class_item_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum class_member {
     instance_var(ident, @ty, class_mutability, node_id),
     class_method(@item) // FIXME: methods aren't allowed to be
@@ -665,21 +665,21 @@ enum class_member {
     // item to separate out things with type params?
 }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum class_mutability { class_mutable, class_immutable }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum privacy { priv, pub }
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type class_ctor = spanned<class_ctor_>;
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type class_ctor_ = {id: node_id,
                     dec: fn_decl,
                     body: blk};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 type native_item =
     {ident: ident,
      attrs: [attribute],
@@ -687,7 +687,7 @@ type native_item =
      id: node_id,
      span: span};
 
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum native_item_ {
     native_item_fn(fn_decl, [ty_param]),
 }
@@ -695,7 +695,7 @@ enum native_item_ {
 // The data we save and restore about an inlined item or method.  This is not
 // part of the AST that we parse from a file, but it becomes part of the tree
 // that we trans.
-/*#[auto_serialize]*/
+#[auto_serialize]
 enum inlined_item {
     ii_item(@item),
     ii_method(def_id /* impl id */, @method)
diff --git a/src/rustc/syntax/fold.rs b/src/rustc/syntax/fold.rs
index 62de1f881ef..0a3e42aee34 100644
--- a/src/rustc/syntax/fold.rs
+++ b/src/rustc/syntax/fold.rs
@@ -117,13 +117,14 @@ fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item {
                   meta_name_value(fld.fold_ident(id), s)
                 }
               },
-          span: mi.span};
+          span: fld.new_span(mi.span)};
 }
 //used in noop_fold_item and noop_fold_crate
-fn fold_attribute_(at: attribute, fmi: fn@(&&@meta_item) -> @meta_item) ->
+fn fold_attribute_(at: attribute, fld: ast_fold) ->
    attribute {
-    ret {node: {style: at.node.style, value: *fmi(@at.node.value)},
-         span: at.span};
+    ret {node: {style: at.node.style,
+                value: *fold_meta_item_(@at.node.value, fld)},
+         span: fld.new_span(at.span)};
 }
 //used in noop_fold_native_item and noop_fold_fn_decl
 fn fold_arg_(a: arg, fld: ast_fold) -> arg {
@@ -148,7 +149,7 @@ fn fold_mac_(m: mac, fld: ast_fold) -> mac {
                mac_aq(_,_) { /* fixme */ m.node }
                mac_var(_) { /* fixme */ m.node }
              },
-         span: m.span};
+         span: fld.new_span(m.span)};
 }
 
 fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
@@ -178,7 +179,7 @@ fn fold_ty_params(tps: [ty_param], fld: ast_fold) -> [ty_param] {
 
 fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
     let fold_meta_item = bind fold_meta_item_(_, fld);
-    let fold_attribute = bind fold_attribute_(_, fold_meta_item);
+    let fold_attribute = bind fold_attribute_(_, fld);
 
     ret {directives: vec::map(c.directives, fld.fold_crate_directive),
          module: fld.fold_mod(c.module),
@@ -208,8 +209,7 @@ fn noop_fold_view_item(vi: view_item_, _fld: ast_fold) -> view_item_ {
 
 fn noop_fold_native_item(&&ni: @native_item, fld: ast_fold) -> @native_item {
     let fold_arg = bind fold_arg_(_, fld);
-    let fold_meta_item = bind fold_meta_item_(_, fld);
-    let fold_attribute = bind fold_attribute_(_, fold_meta_item);
+    let fold_attribute = bind fold_attribute_(_, fld);
 
     ret @{ident: fld.fold_ident(ni.ident),
           attrs: vec::map(ni.attrs, fold_attribute),
@@ -231,8 +231,7 @@ fn noop_fold_native_item(&&ni: @native_item, fld: ast_fold) -> @native_item {
 }
 
 fn noop_fold_item(&&i: @item, fld: ast_fold) -> @item {
-    let fold_meta_item = bind fold_meta_item_(_, fld);
-    let fold_attribute = bind fold_attribute_(_, fold_meta_item);
+    let fold_attribute = bind fold_attribute_(_, fld);
 
     ret @{ident: fld.fold_ident(i.ident),
           attrs: vec::map(i.attrs, fold_attribute),
@@ -252,7 +251,7 @@ fn noop_fold_class_item(&&ci: @class_item, fld: ast_fold)
         }
         class_method(i) { class_method(fld.fold_item(i)) }
          }},
-       span: ci.span}
+       span: fld.new_span(ci.span)}
 }
 
 fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
@@ -374,7 +373,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
                  {mutbl: field.node.mutbl,
                   ident: fld.fold_ident(field.node.ident),
                   expr: fld.fold_expr(field.node.expr)},
-             span: field.span};
+             span: fld.new_span(field.span)};
     }
     let fold_field = bind fold_field_(_, fld);
 
@@ -519,8 +518,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
     let fold_variant_arg = bind fold_variant_arg_(_, fld);
     let args = vec::map(v.args, fold_variant_arg);
 
-    let fold_meta_item = bind fold_meta_item_(_, fld);
-    let fold_attribute = bind fold_attribute_(_, fold_meta_item);
+    let fold_attribute = bind fold_attribute_(_, fld);
     let attrs = vec::map(v.attrs, fold_attribute);
 
     let de = alt v.disr_expr {