Remove the old serializers (needs snapshot)

6 files changed, 230 insertions, 208 deletions

diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs
index 197e567ab2f..6b8c995ffd2 100644
--- a/src/rustc/metadata/decoder.rs
+++ b/src/rustc/metadata/decoder.rs
@@ -1,8 +1,9 @@
 // Decoding metadata from a single crate's metadata
 
-use std::{ebml2, map};
+use std::ebml;
+use std::map;
 use std::map::HashMap;
-use std::serialization2::deserialize;
+use std::serialization::deserialize;
 use io::WriterUtil;
 use dvec::DVec;
 use syntax::{ast, ast_util};
@@ -64,25 +65,25 @@ export translate_def_id;
 // what crate that's in and give us a def_id that makes sense for the current
 // build.
 
-fn lookup_hash(d: ebml2::Doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) ->
-   Option<ebml2::Doc> {
-    let index = ebml2::get_doc(d, tag_index);
-    let table = ebml2::get_doc(index, tag_index_table);
+fn lookup_hash(d: ebml::Doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) ->
+   Option<ebml::Doc> {
+    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 = io::u64_from_be_bytes(*d.data, hash_pos, 4u) as uint;
-    let tagged_doc = ebml2::doc_at(d.data, pos);
+    let tagged_doc = ebml::doc_at(d.data, pos);
 
     let belt = tag_index_buckets_bucket_elt;
-    for ebml2::tagged_docs(tagged_doc.doc, belt) |elt| {
+    for ebml::tagged_docs(tagged_doc.doc, belt) |elt| {
         let pos = io::u64_from_be_bytes(*elt.data, elt.start, 4u) as uint;
         if eq_fn(vec::view(*elt.data, elt.start + 4u, elt.end)) {
-            return Some(ebml2::doc_at(d.data, pos).doc);
+            return Some(ebml::doc_at(d.data, pos).doc);
         }
     };
     None
 }
 
-fn maybe_find_item(item_id: int, items: ebml2::Doc) -> Option<ebml2::Doc> {
+fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
     fn eq_item(bytes: &[u8], item_id: int) -> bool {
         return io::u64_from_be_bytes(vec::view(bytes, 0u, 4u), 0u, 4u) as int
             == item_id;
@@ -92,14 +93,14 @@ fn maybe_find_item(item_id: int, items: ebml2::Doc) -> Option<ebml2::Doc> {
                 item_id.hash() as uint)
 }
 
-fn find_item(item_id: int, items: ebml2::Doc) -> ebml2::Doc {
+fn find_item(item_id: int, items: ebml::Doc) -> ebml::Doc {
     return maybe_find_item(item_id, items).get();
 }
 
-// Looks up an item in the given metadata and returns an ebml2 doc pointing
+// Looks up an item in the given metadata and returns an ebml doc pointing
 // to the item data.
-fn lookup_item(item_id: int, data: @~[u8]) -> ebml2::Doc {
-    let items = ebml2::get_doc(ebml2::Doc(data), tag_items);
+fn lookup_item(item_id: int, data: @~[u8]) -> ebml::Doc {
+    let items = ebml::get_doc(ebml::Doc(data), tag_items);
     match maybe_find_item(item_id, items) {
        None => fail(fmt!("lookup_item: id not found: %d", item_id)),
        Some(d) => d
@@ -137,9 +138,9 @@ impl Family : cmp::Eq {
     pure fn ne(other: &Family) -> bool { !self.eq(other) }
 }
 
-fn item_family(item: ebml2::Doc) -> Family {
-    let fam = ebml2::get_doc(item, tag_items_data_item_family);
-    match ebml2::doc_as_u8(fam) as char {
+fn item_family(item: ebml::Doc) -> Family {
+    let fam = ebml::get_doc(item, tag_items_data_item_family);
+    match ebml::doc_as_u8(fam) as char {
       'c' => Const,
       'f' => Fn,
       'u' => UnsafeFn,
@@ -165,59 +166,59 @@ fn item_family(item: ebml2::Doc) -> Family {
     }
 }
 
-fn item_symbol(item: ebml2::Doc) -> ~str {
-    let sym = ebml2::get_doc(item, tag_items_data_item_symbol);
-    return str::from_bytes(ebml2::doc_data(sym));
+fn item_symbol(item: ebml::Doc) -> ~str {
+    let sym = ebml::get_doc(item, tag_items_data_item_symbol);
+    return str::from_bytes(ebml::doc_data(sym));
 }
 
-fn item_parent_item(d: ebml2::Doc) -> Option<ast::def_id> {
-    for ebml2::tagged_docs(d, tag_items_data_parent_item) |did| {
-        return Some(ebml2::with_doc_data(did, |d| parse_def_id(d)));
+fn item_parent_item(d: ebml::Doc) -> Option<ast::def_id> {
+    for ebml::tagged_docs(d, tag_items_data_parent_item) |did| {
+        return Some(ebml::with_doc_data(did, |d| parse_def_id(d)));
     }
     None
 }
 
-fn item_def_id(d: ebml2::Doc, cdata: cmd) -> ast::def_id {
-    let tagdoc = ebml2::get_doc(d, tag_def_id);
-    return translate_def_id(cdata, ebml2::with_doc_data(tagdoc,
+fn item_def_id(d: ebml::Doc, cdata: cmd) -> ast::def_id {
+    let tagdoc = ebml::get_doc(d, tag_def_id);
+    return translate_def_id(cdata, ebml::with_doc_data(tagdoc,
                                                     |d| parse_def_id(d)));
 }
 
-fn each_reexport(d: ebml2::Doc, f: fn(ebml2::Doc) -> bool) {
-    for ebml2::tagged_docs(d, tag_items_data_item_reexport) |reexport_doc| {
+fn each_reexport(d: ebml::Doc, f: fn(ebml::Doc) -> bool) {
+    for ebml::tagged_docs(d, tag_items_data_item_reexport) |reexport_doc| {
         if !f(reexport_doc) {
             return;
         }
     }
 }
 
-fn field_mutability(d: ebml2::Doc) -> ast::class_mutability {
+fn field_mutability(d: ebml::Doc) -> ast::class_mutability {
     // Use maybe_get_doc in case it's a method
     option::map_default(
-        &ebml2::maybe_get_doc(d, tag_class_mut),
+        &ebml::maybe_get_doc(d, tag_class_mut),
         ast::class_immutable,
         |d| {
-            match ebml2::doc_as_u8(*d) as char {
+            match ebml::doc_as_u8(*d) as char {
               'm' => ast::class_mutable,
               _   => ast::class_immutable
             }
         })
 }
 
-fn variant_disr_val(d: ebml2::Doc) -> Option<int> {
-    do option::chain(ebml2::maybe_get_doc(d, tag_disr_val)) |val_doc| {
-        int::parse_bytes(ebml2::doc_data(val_doc), 10u)
+fn variant_disr_val(d: ebml::Doc) -> Option<int> {
+    do option::chain(ebml::maybe_get_doc(d, tag_disr_val)) |val_doc| {
+        int::parse_bytes(ebml::doc_data(val_doc), 10u)
     }
 }
 
-fn doc_type(doc: ebml2::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::t {
-    let tp = ebml2::get_doc(doc, tag_items_data_item_type);
+fn doc_type(doc: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ty::t {
+    let tp = ebml::get_doc(doc, tag_items_data_item_type);
     parse_ty_data(tp.data, cdata.cnum, tp.start, tcx, |did| {
         translate_def_id(cdata, did)
     })
 }
 
-fn item_type(item_id: ast::def_id, item: ebml2::Doc,
+fn item_type(item_id: ast::def_id, item: ebml::Doc,
              tcx: ty::ctxt, cdata: cmd) -> ty::t {
     let t = doc_type(item, tcx, cdata);
     if family_names_type(item_family(item)) {
@@ -225,18 +226,18 @@ fn item_type(item_id: ast::def_id, item: ebml2::Doc,
     } else { t }
 }
 
-fn item_impl_traits(item: ebml2::Doc, tcx: ty::ctxt, cdata: cmd) -> ~[ty::t] {
+fn item_impl_traits(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd) -> ~[ty::t] {
     let mut results = ~[];
-    for ebml2::tagged_docs(item, tag_impl_trait) |ity| {
+    for ebml::tagged_docs(item, tag_impl_trait) |ity| {
         results.push(doc_type(ity, tcx, cdata));
     };
     results
 }
 
-fn item_ty_param_bounds(item: ebml2::Doc, tcx: ty::ctxt, cdata: cmd)
+fn item_ty_param_bounds(item: ebml::Doc, tcx: ty::ctxt, cdata: cmd)
     -> @~[ty::param_bounds] {
     let mut bounds = ~[];
-    for ebml2::tagged_docs(item, tag_items_data_item_ty_param_bounds) |p| {
+    for ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) |p| {
         let bd = parse_bounds_data(p.data, p.start, cdata.cnum, tcx, |did| {
             translate_def_id(cdata, did)
         });
@@ -245,42 +246,42 @@ fn item_ty_param_bounds(item: ebml2::Doc, tcx: ty::ctxt, cdata: cmd)
     @bounds
 }
 
-fn item_ty_region_param(item: ebml2::Doc) -> Option<ty::region_variance> {
-    ebml2::maybe_get_doc(item, tag_region_param).map(|doc| {
-        deserialize(&ebml2::Deserializer(*doc))
+fn item_ty_region_param(item: ebml::Doc) -> Option<ty::region_variance> {
+    ebml::maybe_get_doc(item, tag_region_param).map(|doc| {
+        deserialize(&ebml::Deserializer(*doc))
     })
 }
 
-fn item_ty_param_count(item: ebml2::Doc) -> uint {
+fn item_ty_param_count(item: ebml::Doc) -> uint {
     let mut n = 0u;
-    ebml2::tagged_docs(item, tag_items_data_item_ty_param_bounds,
+    ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds,
                       |_p| { n += 1u; true } );
     n
 }
 
-fn enum_variant_ids(item: ebml2::Doc, cdata: cmd) -> ~[ast::def_id] {
+fn enum_variant_ids(item: ebml::Doc, cdata: cmd) -> ~[ast::def_id] {
     let mut ids: ~[ast::def_id] = ~[];
     let v = tag_items_data_item_variant;
-    for ebml2::tagged_docs(item, v) |p| {
-        let ext = ebml2::with_doc_data(p, |d| parse_def_id(d));
+    for ebml::tagged_docs(item, v) |p| {
+        let ext = ebml::with_doc_data(p, |d| parse_def_id(d));
         ids.push({crate: cdata.cnum, node: ext.node});
     };
     return ids;
 }
 
-fn item_path(intr: @ident_interner, item_doc: ebml2::Doc) -> ast_map::path {
-    let path_doc = ebml2::get_doc(item_doc, tag_path);
+fn item_path(intr: @ident_interner, item_doc: ebml::Doc) -> ast_map::path {
+    let path_doc = ebml::get_doc(item_doc, tag_path);
 
-    let len_doc = ebml2::get_doc(path_doc, tag_path_len);
-    let len = ebml2::doc_as_u32(len_doc) as uint;
+    let len_doc = ebml::get_doc(path_doc, tag_path_len);
+    let len = ebml::doc_as_u32(len_doc) as uint;
 
     let mut result = vec::with_capacity(len);
-    for ebml2::docs(path_doc) |tag, elt_doc| {
+    for ebml::docs(path_doc) |tag, elt_doc| {
         if tag == tag_path_elt_mod {
-            let str = ebml2::doc_as_str(elt_doc);
+            let str = ebml::doc_as_str(elt_doc);
             result.push(ast_map::path_mod(intr.intern(@str)));
         } else if tag == tag_path_elt_name {
-            let str = ebml2::doc_as_str(elt_doc);
+            let str = ebml::doc_as_str(elt_doc);
             result.push(ast_map::path_name(intr.intern(@str)));
         } else {
             // ignore tag_path_len element
@@ -290,12 +291,12 @@ fn item_path(intr: @ident_interner, item_doc: ebml2::Doc) -> ast_map::path {
     return result;
 }
 
-fn item_name(intr: @ident_interner, item: ebml2::Doc) -> ast::ident {
-    let name = ebml2::get_doc(item, tag_paths_data_name);
-    intr.intern(@str::from_bytes(ebml2::doc_data(name)))
+fn item_name(intr: @ident_interner, item: ebml::Doc) -> ast::ident {
+    let name = ebml::get_doc(item, tag_paths_data_name);
+    intr.intern(@str::from_bytes(ebml::doc_data(name)))
 }
 
-fn item_to_def_like(item: ebml2::Doc, did: ast::def_id, cnum: ast::crate_num)
+fn item_to_def_like(item: ebml::Doc, did: ast::def_id, cnum: ast::crate_num)
         -> def_like {
     let fam = item_family(item);
     match fam {
@@ -367,10 +368,10 @@ fn get_impl_traits(cdata: cmd, id: ast::node_id, tcx: ty::ctxt) -> ~[ty::t] {
 
 fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                    name: ast::ident) -> ast::def_id {
-    let items = ebml2::get_doc(ebml2::Doc(cdata.data), tag_items);
+    let items = ebml::get_doc(ebml::Doc(cdata.data), tag_items);
     let mut found = None;
-    for ebml2::tagged_docs(find_item(id, items), tag_item_impl_method) |mid| {
-        let m_did = ebml2::with_doc_data(mid, |d| parse_def_id(d));
+    for ebml::tagged_docs(find_item(id, items), tag_item_impl_method) |mid| {
+        let m_did = ebml::with_doc_data(mid, |d| parse_def_id(d));
         if item_name(intr, find_item(m_did.node, items)) == name {
             found = Some(translate_def_id(cdata, m_did));
         }
@@ -380,14 +381,14 @@ fn get_impl_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
 
 fn get_class_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                     name: ast::ident) -> ast::def_id {
-    let items = ebml2::get_doc(ebml2::Doc(cdata.data), tag_items);
+    let items = ebml::get_doc(ebml::Doc(cdata.data), tag_items);
     let mut found = None;
     let cls_items = match maybe_find_item(id, items) {
       Some(it) => it,
       None => fail (fmt!("get_class_method: class id not found \
                               when looking up method %s", *intr.get(name)))
     };
-    for ebml2::tagged_docs(cls_items, tag_item_trait_method) |mid| {
+    for ebml::tagged_docs(cls_items, tag_item_trait_method) |mid| {
         let m_did = item_def_id(mid, cdata);
         if item_name(intr, mid) == name {
             found = Some(m_did);
@@ -401,16 +402,16 @@ fn get_class_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
 }
 
 fn class_dtor(cdata: cmd, id: ast::node_id) -> Option<ast::def_id> {
-    let items = ebml2::get_doc(ebml2::Doc(cdata.data), tag_items);
+    let items = ebml::get_doc(ebml::Doc(cdata.data), tag_items);
     let mut found = None;
     let cls_items = match maybe_find_item(id, items) {
             Some(it) => it,
             None     => fail (fmt!("class_dtor: class id not found \
               when looking up dtor for %d", id))
     };
-    for ebml2::tagged_docs(cls_items, tag_item_dtor) |doc| {
-         let doc1 = ebml2::get_doc(doc, tag_def_id);
-         let did = ebml2::with_doc_data(doc1, |d| parse_def_id(d));
+    for ebml::tagged_docs(cls_items, tag_item_dtor) |doc| {
+         let doc1 = ebml::get_doc(doc, tag_def_id);
+         let did = ebml::with_doc_data(doc1, |d| parse_def_id(d));
          found = Some(translate_def_id(cdata, did));
     };
     found
@@ -452,14 +453,14 @@ fn path_entry(path_string: ~str, def_like: def_like) -> path_entry {
 
 /// Iterates over all the paths in the given crate.
 fn each_path(intr: @ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
-    let root = ebml2::Doc(cdata.data);
-    let items = ebml2::get_doc(root, tag_items);
-    let items_data = ebml2::get_doc(items, tag_items_data);
+    let root = ebml::Doc(cdata.data);
+    let items = ebml::get_doc(root, tag_items);
+    let items_data = ebml::get_doc(items, tag_items_data);
 
     let mut broken = false;
 
     // First, go through all the explicit items.
-    for ebml2::tagged_docs(items_data, tag_items_data_item) |item_doc| {
+    for ebml::tagged_docs(items_data, tag_items_data_item) |item_doc| {
         if !broken {
             let path = ast_map::path_to_str_with_sep(
                 item_path(intr, item_doc), ~"::", intr);
@@ -482,16 +483,16 @@ fn each_path(intr: @ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
             for each_reexport(item_doc) |reexport_doc| {
                 if !broken {
                     let def_id_doc =
-                        ebml2::get_doc(reexport_doc,
+                        ebml::get_doc(reexport_doc,
                             tag_items_data_item_reexport_def_id);
                     let def_id =
-                        ebml2::with_doc_data(def_id_doc, |d| parse_def_id(d));
+                        ebml::with_doc_data(def_id_doc, |d| parse_def_id(d));
                     let def_id = translate_def_id(cdata, def_id);
 
                     let reexport_name_doc =
-                        ebml2::get_doc(reexport_doc,
+                        ebml::get_doc(reexport_doc,
                                       tag_items_data_item_reexport_name);
-                    let reexport_name = ebml2::doc_as_str(reexport_name_doc);
+                    let reexport_name = ebml::doc_as_str(reexport_name_doc);
 
                     let reexport_path;
                     if path == ~"" {
@@ -540,7 +541,7 @@ type decode_inlined_item = fn(
     cdata: cstore::crate_metadata,
     tcx: ty::ctxt,
     path: ast_map::path,
-    par_doc: ebml2::Doc) -> Option<ast::inlined_item>;
+    par_doc: ebml::Doc) -> Option<ast::inlined_item>;
 
 fn maybe_get_item_ast(intr: @ident_interner, cdata: cmd, tcx: ty::ctxt,
                       id: ast::node_id,
@@ -571,7 +572,7 @@ fn maybe_get_item_ast(intr: @ident_interner, cdata: cmd, tcx: ty::ctxt,
 fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                      tcx: ty::ctxt) -> ~[ty::variant_info] {
     let data = cdata.data;
-    let items = ebml2::get_doc(ebml2::Doc(data), tag_items);
+    let items = ebml::get_doc(ebml::Doc(data), tag_items);
     let item = find_item(id, items);
     let mut infos: ~[ty::variant_info] = ~[];
     let variant_ids = enum_variant_ids(item, cdata);
@@ -609,7 +610,7 @@ type method_info = {
 
 type _impl = {did: ast::def_id, ident: ast::ident, methods: ~[@method_info]};
 
-fn get_self_ty(item: ebml2::Doc) -> ast::self_ty_ {
+fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ {
     fn get_mutability(ch: u8) -> ast::mutability {
         match ch as char {
             'i' => { ast::m_imm }
@@ -621,8 +622,8 @@ fn get_self_ty(item: ebml2::Doc) -> ast::self_ty_ {
         }
     }
 
-    let self_type_doc = ebml2::get_doc(item, tag_item_trait_method_self_ty);
-    let string = ebml2::doc_as_str(self_type_doc);
+    let self_type_doc = ebml::get_doc(item, tag_item_trait_method_self_ty);
+    let string = ebml::doc_as_str(self_type_doc);
 
     let self_ty_kind = string[0];
     match self_ty_kind as char {
@@ -638,11 +639,11 @@ fn get_self_ty(item: ebml2::Doc) -> ast::self_ty_ {
     }
 }
 
-fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml2::Doc,
+fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc,
                      base_tps: uint) -> ~[@method_info] {
     let mut rslt = ~[];
-    for ebml2::tagged_docs(item, tag_item_impl_method) |doc| {
-        let m_did = ebml2::with_doc_data(doc, |d| parse_def_id(d));
+    for ebml::tagged_docs(item, tag_item_impl_method) |doc| {
+        let m_did = ebml::with_doc_data(doc, |d| parse_def_id(d));
         let mth_item = lookup_item(m_did.node, cdata.data);
         let self_ty = get_self_ty(mth_item);
         rslt.push(@{did: translate_def_id(cdata, m_did),
@@ -662,8 +663,8 @@ fn get_impls_for_mod(intr: @ident_interner, cdata: cmd,
     let data = cdata.data;
     let mod_item = lookup_item(m_id, data);
     let mut result = ~[];
-    for ebml2::tagged_docs(mod_item, tag_mod_impl) |doc| {
-        let did = ebml2::with_doc_data(doc, |d| parse_def_id(d));
+    for ebml::tagged_docs(mod_item, tag_mod_impl) |doc| {
+        let did = ebml::with_doc_data(doc, |d| parse_def_id(d));
         let local_did = translate_def_id(cdata, did);
         debug!("(get impls for mod) getting did %? for '%?'",
                local_did, name);
@@ -690,7 +691,7 @@ fn get_trait_methods(intr: @ident_interner, cdata: cmd, id: ast::node_id,
     let data = cdata.data;
     let item = lookup_item(id, data);
     let mut result = ~[];
-    for ebml2::tagged_docs(item, tag_item_trait_method) |mth| {
+    for ebml::tagged_docs(item, tag_item_trait_method) |mth| {
         let bounds = item_ty_param_bounds(mth, tcx, cdata);
         let name = item_name(intr, mth);
         let ty = doc_type(mth, tcx, cdata);
@@ -722,7 +723,7 @@ fn get_method_names_if_trait(intr: @ident_interner, cdata: cmd,
     }
 
     let resulting_methods = @DVec();
-    for ebml2::tagged_docs(item, tag_item_trait_method) |method| {
+    for ebml::tagged_docs(item, tag_item_trait_method) |method| {
         resulting_methods.push(
             (item_name(intr, method), get_self_ty(method)));
     }
@@ -734,8 +735,8 @@ fn get_item_attrs(cdata: cmd,
                   f: fn(~[@ast::meta_item])) {
 
     let item = lookup_item(node_id, cdata.data);
-    for ebml2::tagged_docs(item, tag_attributes) |attributes| {
-        for ebml2::tagged_docs(attributes, tag_attribute) |attribute| {
+    for ebml::tagged_docs(item, tag_attributes) |attributes| {
+        for ebml::tagged_docs(attributes, tag_attribute) |attribute| {
             f(get_meta_items(attribute));
         }
     }
@@ -747,7 +748,7 @@ fn get_class_members(intr: @ident_interner, cdata: cmd, id: ast::node_id,
     let data = cdata.data;
     let item = lookup_item(id, data);
     let mut result = ~[];
-    for ebml2::tagged_docs(item, tag_item_field) |an_item| {
+    for ebml::tagged_docs(item, tag_item_field) |an_item| {
        let f = item_family(an_item);
        if p(f) {
           let name = item_name(intr, an_item);
@@ -787,15 +788,15 @@ fn family_names_type(fam: Family) -> bool {
     match fam { Type | Mod | Trait => true, _ => false }
 }
 
-fn read_path(d: ebml2::Doc) -> {path: ~str, pos: uint} {
-    let desc = ebml2::doc_data(d);
+fn read_path(d: ebml::Doc) -> {path: ~str, pos: uint} {
+    let desc = ebml::doc_data(d);
     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);
     return {path: path, pos: pos};
 }
 
-fn describe_def(items: ebml2::Doc, id: ast::def_id) -> ~str {
+fn describe_def(items: ebml::Doc, id: ast::def_id) -> ~str {
     if id.crate != ast::local_crate { return ~"external"; }
     let it = match maybe_find_item(id.node, items) {
         Some(it) => it,
@@ -830,36 +831,36 @@ fn item_family_to_str(fam: Family) -> ~str {
     }
 }
 
-fn get_meta_items(md: ebml2::Doc) -> ~[@ast::meta_item] {
+fn get_meta_items(md: ebml::Doc) -> ~[@ast::meta_item] {
     let mut items: ~[@ast::meta_item] = ~[];
-    for ebml2::tagged_docs(md, tag_meta_item_word) |meta_item_doc| {
-        let nd = ebml2::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = str::from_bytes(ebml2::doc_data(nd));
+    for ebml::tagged_docs(md, tag_meta_item_word) |meta_item_doc| {
+        let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
+        let n = str::from_bytes(ebml::doc_data(nd));
         items.push(attr::mk_word_item(n));
     };
-    for ebml2::tagged_docs(md, tag_meta_item_name_value) |meta_item_doc| {
-        let nd = ebml2::get_doc(meta_item_doc, tag_meta_item_name);
-        let vd = ebml2::get_doc(meta_item_doc, tag_meta_item_value);
-        let n = str::from_bytes(ebml2::doc_data(nd));
-        let v = str::from_bytes(ebml2::doc_data(vd));
+    for ebml::tagged_docs(md, tag_meta_item_name_value) |meta_item_doc| {
+        let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
+        let vd = ebml::get_doc(meta_item_doc, tag_meta_item_value);
+        let n = str::from_bytes(ebml::doc_data(nd));
+        let v = str::from_bytes(ebml::doc_data(vd));
         // FIXME (#623): Should be able to decode meta_name_value variants,
         // but currently the encoder just drops them
         items.push(attr::mk_name_value_item_str(n, v));
     };
-    for ebml2::tagged_docs(md, tag_meta_item_list) |meta_item_doc| {
-        let nd = ebml2::get_doc(meta_item_doc, tag_meta_item_name);
-        let n = str::from_bytes(ebml2::doc_data(nd));
+    for ebml::tagged_docs(md, tag_meta_item_list) |meta_item_doc| {
+        let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
+        let n = str::from_bytes(ebml::doc_data(nd));
         let subitems = get_meta_items(meta_item_doc);
         items.push(attr::mk_list_item(n, subitems));
     };
     return items;
 }
 
-fn get_attributes(md: ebml2::Doc) -> ~[ast::attribute] {
+fn get_attributes(md: ebml::Doc) -> ~[ast::attribute] {
     let mut attrs: ~[ast::attribute] = ~[];
-    match ebml2::maybe_get_doc(md, tag_attributes) {
+    match ebml::maybe_get_doc(md, tag_attributes) {
       option::Some(attrs_d) => {
-        for ebml2::tagged_docs(attrs_d, tag_attribute) |attr_doc| {
+        for ebml::tagged_docs(attrs_d, tag_attribute) |attr_doc| {
             let meta_items = get_meta_items(attr_doc);
             // Currently it's only possible to have a single meta item on
             // an attribute
@@ -877,13 +878,13 @@ fn get_attributes(md: ebml2::Doc) -> ~[ast::attribute] {
 }
 
 fn list_meta_items(intr: @ident_interner,
-                   meta_items: ebml2::Doc, out: io::Writer) {
+                   meta_items: ebml::Doc, out: io::Writer) {
     for get_meta_items(meta_items).each |mi| {
         out.write_str(fmt!("%s\n", pprust::meta_item_to_str(*mi, intr)));
     }
 }
 
-fn list_crate_attributes(intr: @ident_interner, md: ebml2::Doc, hash: ~str,
+fn list_crate_attributes(intr: @ident_interner, md: ebml::Doc, hash: ~str,
                          out: io::Writer) {
     out.write_str(fmt!("=Crate Attributes (%s)=\n", hash));
 
@@ -895,7 +896,7 @@ fn list_crate_attributes(intr: @ident_interner, md: ebml2::Doc, hash: ~str,
 }
 
 fn get_crate_attributes(data: @~[u8]) -> ~[ast::attribute] {
-    return get_attributes(ebml2::Doc(data));
+    return get_attributes(ebml::Doc(data));
 }
 
 type crate_dep = {cnum: ast::crate_num, name: ast::ident,
@@ -903,13 +904,13 @@ type crate_dep = {cnum: ast::crate_num, name: ast::ident,
 
 fn get_crate_deps(intr: @ident_interner, data: @~[u8]) -> ~[crate_dep] {
     let mut deps: ~[crate_dep] = ~[];
-    let cratedoc = ebml2::Doc(data);
-    let depsdoc = ebml2::get_doc(cratedoc, tag_crate_deps);
+    let cratedoc = ebml::Doc(data);
+    let depsdoc = ebml::get_doc(cratedoc, tag_crate_deps);
     let mut crate_num = 1;
-    fn docstr(doc: ebml2::Doc, tag_: uint) -> ~str {
-        str::from_bytes(ebml2::doc_data(ebml2::get_doc(doc, tag_)))
+    fn docstr(doc: ebml::Doc, tag_: uint) -> ~str {
+        str::from_bytes(ebml::doc_data(ebml::get_doc(doc, tag_)))
     }
-    for ebml2::tagged_docs(depsdoc, tag_crate_dep) |depdoc| {
+    for ebml::tagged_docs(depsdoc, tag_crate_dep) |depdoc| {
         deps.push({cnum: crate_num,
                   name: intr.intern(@docstr(depdoc, tag_crate_dep_name)),
                   vers: docstr(depdoc, tag_crate_dep_vers),
@@ -932,9 +933,9 @@ fn list_crate_deps(intr: @ident_interner, data: @~[u8], out: io::Writer) {
 }
 
 fn get_crate_hash(data: @~[u8]) -> ~str {
-    let cratedoc = ebml2::Doc(data);
-    let hashdoc = ebml2::get_doc(cratedoc, tag_crate_hash);
-    return str::from_bytes(ebml2::doc_data(hashdoc));
+    let cratedoc = ebml::Doc(data);
+    let hashdoc = ebml::get_doc(cratedoc, tag_crate_hash);
+    return str::from_bytes(ebml::doc_data(hashdoc));
 }
 
 fn get_crate_vers(data: @~[u8]) -> ~str {
@@ -988,7 +989,7 @@ fn get_crate_module_paths(intr: @ident_interner, cdata: cmd)
 fn list_crate_metadata(intr: @ident_interner, bytes: @~[u8],
                        out: io::Writer) {
     let hash = get_crate_hash(bytes);
-    let md = ebml2::Doc(bytes);
+    let md = ebml::Doc(bytes);
     list_crate_attributes(intr, md, hash, out);
     list_crate_deps(intr, bytes, out);
 }
diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs
index 95696a14156..f188d8ee5d8 100644
--- a/src/rustc/metadata/encoder.rs
+++ b/src/rustc/metadata/encoder.rs
@@ -2,10 +2,10 @@
 
 use util::ppaux::ty_to_str;
 
-use std::{ebml2, map};
+use std::{ebml, map};
 use std::map::HashMap;
 use io::WriterUtil;
-use ebml2::Serializer;
+use ebml::Serializer;
 use syntax::ast::*;
 use syntax::print::pprust;
 use syntax::{ast_util, visit};
@@ -40,7 +40,7 @@ export encode_def_id;
 type abbrev_map = map::HashMap<ty::t, tyencode::ty_abbrev>;
 
 type encode_inlined_item = fn@(ecx: @encode_ctxt,
-                               ebml_w: ebml2::Serializer,
+                               ebml_w: ebml::Serializer,
                                path: ast_map::path,
                                ii: ast::inlined_item);
 
@@ -86,15 +86,15 @@ fn reachable(ecx: @encode_ctxt, id: node_id) -> bool {
     ecx.reachable.contains_key(id)
 }
 
-fn encode_name(ecx: @encode_ctxt, ebml_w: ebml2::Serializer, name: ident) {
+fn encode_name(ecx: @encode_ctxt, ebml_w: ebml::Serializer, name: ident) {
     ebml_w.wr_tagged_str(tag_paths_data_name, ecx.tcx.sess.str_of(name));
 }
 
-fn encode_def_id(ebml_w: ebml2::Serializer, id: def_id) {
+fn encode_def_id(ebml_w: ebml::Serializer, id: def_id) {
     ebml_w.wr_tagged_str(tag_def_id, def_to_str(id));
 }
 
-fn encode_region_param(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_region_param(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                        it: @ast::item) {
     let opt_rp = ecx.tcx.region_paramd_items.find(it.id);
     for opt_rp.each |rp| {
@@ -104,7 +104,7 @@ fn encode_region_param(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
     }
 }
 
-fn encode_mutability(ebml_w: ebml2::Serializer, mt: class_mutability) {
+fn encode_mutability(ebml_w: ebml::Serializer, mt: class_mutability) {
     do ebml_w.wr_tag(tag_class_mut) {
         let val = match mt {
           class_immutable => 'a',
@@ -116,7 +116,7 @@ fn encode_mutability(ebml_w: ebml2::Serializer, mt: class_mutability) {
 
 type entry<T> = {val: T, pos: uint};
 
-fn add_to_index(ecx: @encode_ctxt, ebml_w: ebml2::Serializer, path: &[ident],
+fn add_to_index(ecx: @encode_ctxt, ebml_w: ebml::Serializer, path: &[ident],
                 index: &mut ~[entry<~str>], name: ident) {
     let mut full_path = ~[];
     full_path.push_all(path);
@@ -127,7 +127,7 @@ fn add_to_index(ecx: @encode_ctxt, ebml_w: ebml2::Serializer, path: &[ident],
          pos: ebml_w.writer.tell()});
 }
 
-fn encode_trait_ref(ebml_w: ebml2::Serializer, ecx: @encode_ctxt,
+fn encode_trait_ref(ebml_w: ebml::Serializer, ecx: @encode_ctxt,
                     t: @trait_ref) {
     ebml_w.start_tag(tag_impl_trait);
     encode_type(ecx, ebml_w, node_id_to_type(ecx.tcx, t.ref_id));
@@ -136,7 +136,7 @@ fn encode_trait_ref(ebml_w: ebml2::Serializer, ecx: @encode_ctxt,
 
 
 // Item info table encoding
-fn encode_family(ebml_w: ebml2::Serializer, c: char) {
+fn encode_family(ebml_w: ebml::Serializer, c: char) {
     ebml_w.start_tag(tag_items_data_item_family);
     ebml_w.writer.write(&[c as u8]);
     ebml_w.end_tag();
@@ -144,7 +144,7 @@ fn encode_family(ebml_w: ebml2::Serializer, c: char) {
 
 fn def_to_str(did: def_id) -> ~str { fmt!("%d:%d", did.crate, did.node) }
 
-fn encode_ty_type_param_bounds(ebml_w: ebml2::Serializer, ecx: @encode_ctxt,
+fn encode_ty_type_param_bounds(ebml_w: ebml::Serializer, ecx: @encode_ctxt,
                                params: @~[ty::param_bounds]) {
     let ty_str_ctxt = @{diag: ecx.diag,
                         ds: def_to_str,
@@ -158,7 +158,7 @@ fn encode_ty_type_param_bounds(ebml_w: ebml2::Serializer, ecx: @encode_ctxt,
     }
 }
 
-fn encode_type_param_bounds(ebml_w: ebml2::Serializer, ecx: @encode_ctxt,
+fn encode_type_param_bounds(ebml_w: ebml::Serializer, ecx: @encode_ctxt,
                             params: ~[ty_param]) {
     let ty_param_bounds =
         @params.map(|param| ecx.tcx.ty_param_bounds.get(param.id));
@@ -166,13 +166,13 @@ fn encode_type_param_bounds(ebml_w: ebml2::Serializer, ecx: @encode_ctxt,
 }
 
 
-fn encode_variant_id(ebml_w: ebml2::Serializer, vid: def_id) {
+fn encode_variant_id(ebml_w: ebml::Serializer, vid: def_id) {
     ebml_w.start_tag(tag_items_data_item_variant);
     ebml_w.writer.write(str::to_bytes(def_to_str(vid)));
     ebml_w.end_tag();
 }
 
-fn write_type(ecx: @encode_ctxt, ebml_w: ebml2::Serializer, typ: ty::t) {
+fn write_type(ecx: @encode_ctxt, ebml_w: ebml::Serializer, typ: ty::t) {
     let ty_str_ctxt =
         @{diag: ecx.diag,
           ds: def_to_str,
@@ -182,7 +182,7 @@ fn write_type(ecx: @encode_ctxt, ebml_w: ebml2::Serializer, typ: ty::t) {
     tyencode::enc_ty(ebml_w.writer, ty_str_ctxt, typ);
 }
 
-fn write_vstore(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn write_vstore(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                 vstore: ty::vstore) {
     let ty_str_ctxt =
         @{diag: ecx.diag,
@@ -193,13 +193,13 @@ fn write_vstore(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
     tyencode::enc_vstore(ebml_w.writer, ty_str_ctxt, vstore);
 }
 
-fn encode_type(ecx: @encode_ctxt, ebml_w: ebml2::Serializer, typ: ty::t) {
+fn encode_type(ecx: @encode_ctxt, ebml_w: ebml::Serializer, typ: ty::t) {
     ebml_w.start_tag(tag_items_data_item_type);
     write_type(ecx, ebml_w, typ);
     ebml_w.end_tag();
 }
 
-fn encode_symbol(ecx: @encode_ctxt, ebml_w: ebml2::Serializer, id: node_id) {
+fn encode_symbol(ecx: @encode_ctxt, ebml_w: ebml::Serializer, id: node_id) {
     ebml_w.start_tag(tag_items_data_item_symbol);
     let sym = match ecx.item_symbols.find(id) {
       Some(x) => x,
@@ -212,27 +212,27 @@ fn encode_symbol(ecx: @encode_ctxt, ebml_w: ebml2::Serializer, id: node_id) {
     ebml_w.end_tag();
 }
 
-fn encode_discriminant(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_discriminant(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                        id: node_id) {
     ebml_w.start_tag(tag_items_data_item_symbol);
     ebml_w.writer.write(str::to_bytes(ecx.discrim_symbols.get(id)));
     ebml_w.end_tag();
 }
 
-fn encode_disr_val(_ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_disr_val(_ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                    disr_val: int) {
     ebml_w.start_tag(tag_disr_val);
     ebml_w.writer.write(str::to_bytes(int::to_str(disr_val,10u)));
     ebml_w.end_tag();
 }
 
-fn encode_parent_item(ebml_w: ebml2::Serializer, id: def_id) {
+fn encode_parent_item(ebml_w: ebml::Serializer, id: def_id) {
     ebml_w.start_tag(tag_items_data_parent_item);
     ebml_w.writer.write(str::to_bytes(def_to_str(id)));
     ebml_w.end_tag();
 }
 
-fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                             id: node_id, variants: ~[variant],
                             path: ast_map::path, index: @mut ~[entry<int>],
                             ty_params: ~[ty_param]) {
@@ -269,9 +269,9 @@ fn encode_enum_variant_info(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
     }
 }
 
-fn encode_path(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_path(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                path: ast_map::path, name: ast_map::path_elt) {
-    fn encode_path_elt(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+    fn encode_path_elt(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                        elt: ast_map::path_elt) {
         let (tag, name) = match elt {
           ast_map::path_mod(name) => (tag_path_elt_mod, name),
@@ -290,7 +290,7 @@ fn encode_path(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
     }
 }
 
-fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml2::Serializer, md: _mod,
+fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml::Serializer, md: _mod,
                        id: node_id, path: ast_map::path, name: ident) {
     ebml_w.start_tag(tag_items_data_item);
     encode_def_id(ebml_w, local_def(id));
@@ -348,7 +348,7 @@ fn encode_info_for_mod(ecx: @encode_ctxt, ebml_w: ebml2::Serializer, md: _mod,
     ebml_w.end_tag();
 }
 
-fn encode_visibility(ebml_w: ebml2::Serializer, visibility: visibility) {
+fn encode_visibility(ebml_w: ebml::Serializer, visibility: visibility) {
     encode_family(ebml_w, match visibility {
         public => 'g',
         private => 'j',
@@ -356,7 +356,7 @@ fn encode_visibility(ebml_w: ebml2::Serializer, visibility: visibility) {
     });
 }
 
-fn encode_self_type(ebml_w: ebml2::Serializer, self_type: ast::self_ty_) {
+fn encode_self_type(ebml_w: ebml::Serializer, self_type: ast::self_ty_) {
     ebml_w.start_tag(tag_item_trait_method_self_ty);
 
     // Encode the base self type.
@@ -389,7 +389,7 @@ fn encode_self_type(ebml_w: ebml2::Serializer, self_type: ast::self_ty_) {
 }
 
 /* Returns an index of items in this class */
-fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                          id: node_id, path: ast_map::path,
                          class_tps: ~[ty_param],
                          fields: ~[@struct_field],
@@ -445,7 +445,7 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
 }
 
 // This is for encoding info for ctors and dtors
-fn encode_info_for_ctor(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_info_for_ctor(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                         id: node_id, ident: ident, path: ast_map::path,
                         item: Option<inlined_item>, tps: ~[ty_param]) {
         ebml_w.start_tag(tag_items_data_item);
@@ -470,7 +470,7 @@ fn encode_info_for_ctor(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
         ebml_w.end_tag();
 }
 
-fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                           impl_path: ast_map::path, should_inline: bool,
                           parent_id: node_id,
                           m: @method, all_tps: ~[ty_param]) {
@@ -520,7 +520,7 @@ fn should_inline(attrs: ~[attribute]) -> bool {
 }
 
 
-fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                         item: @item, index: @mut ~[entry<int>],
                         path: ast_map::path) {
 
@@ -533,7 +533,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
         };
     if !must_write && !reachable(ecx, item.id) { return; }
 
-    fn add_to_index_(item: @item, ebml_w: ebml2::Serializer,
+    fn add_to_index_(item: @item, ebml_w: ebml::Serializer,
                      index: @mut ~[entry<int>]) {
         index.push({val: item.id, pos: ebml_w.writer.tell()});
     }
@@ -810,7 +810,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
     }
 }
 
-fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                                 nitem: @foreign_item,
                                 index: @mut ~[entry<int>],
                                 path: ast_map::path, abi: foreign_abi) {
@@ -843,7 +843,7 @@ fn encode_info_for_foreign_item(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
     ebml_w.end_tag();
 }
 
-fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                          crate: @crate) -> ~[entry<int>] {
     let index = @mut ~[];
     ebml_w.start_tag(tag_items_data);
@@ -898,7 +898,7 @@ fn create_index<T: Copy Hash IterBytes>(index: ~[entry<T>]) ->
     return buckets_frozen;
 }
 
-fn encode_index<T>(ebml_w: ebml2::Serializer, buckets: ~[@~[entry<T>]],
+fn encode_index<T>(ebml_w: ebml::Serializer, buckets: ~[@~[entry<T>]],
                    write_fn: fn(io::Writer, T)) {
     let writer = ebml_w.writer;
     ebml_w.start_tag(tag_index);
@@ -933,7 +933,7 @@ fn write_int(writer: io::Writer, &&n: int) {
     writer.write_be_u32(n as u32);
 }
 
-fn encode_meta_item(ebml_w: ebml2::Serializer, mi: meta_item) {
+fn encode_meta_item(ebml_w: ebml::Serializer, mi: meta_item) {
     match mi.node {
       meta_word(name) => {
         ebml_w.start_tag(tag_meta_item_word);
@@ -970,7 +970,7 @@ fn encode_meta_item(ebml_w: ebml2::Serializer, mi: meta_item) {
     }
 }
 
-fn encode_attributes(ebml_w: ebml2::Serializer, attrs: ~[attribute]) {
+fn encode_attributes(ebml_w: ebml::Serializer, attrs: ~[attribute]) {
     ebml_w.start_tag(tag_attributes);
     for attrs.each |attr| {
         ebml_w.start_tag(tag_attribute);
@@ -1031,7 +1031,7 @@ fn synthesize_crate_attrs(ecx: @encode_ctxt, crate: @crate) -> ~[attribute] {
     return attrs;
 }
 
-fn encode_crate_deps(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_crate_deps(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                      cstore: cstore::cstore) {
 
     fn get_ordered_deps(ecx: @encode_ctxt, cstore: cstore::cstore)
@@ -1077,7 +1077,7 @@ fn encode_crate_deps(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
     ebml_w.end_tag();
 }
 
-fn encode_crate_dep(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
+fn encode_crate_dep(ecx: @encode_ctxt, ebml_w: ebml::Serializer,
                     dep: decoder::crate_dep) {
     ebml_w.start_tag(tag_crate_dep);
     ebml_w.start_tag(tag_crate_dep_name);
@@ -1092,7 +1092,7 @@ fn encode_crate_dep(ecx: @encode_ctxt, ebml_w: ebml2::Serializer,
     ebml_w.end_tag();
 }
 
-fn encode_hash(ebml_w: ebml2::Serializer, hash: ~str) {
+fn encode_hash(ebml_w: ebml::Serializer, hash: ~str) {
     ebml_w.start_tag(tag_crate_hash);
     ebml_w.writer.write(str::to_bytes(hash));
     ebml_w.end_tag();
@@ -1130,7 +1130,7 @@ fn encode_metadata(parms: encode_parms, crate: @crate) -> ~[u8] {
         type_abbrevs: ty::new_ty_hash()
      });
 
-    let ebml_w = ebml2::Serializer(wr as io::Writer);
+    let ebml_w = ebml::Serializer(wr as io::Writer);
 
     encode_hash(ebml_w, ecx.link_meta.extras_hash);
 
diff --git a/src/rustc/middle/astencode.rs b/src/rustc/middle/astencode.rs
index 39ec58c079e..103f1eecf87 100644
--- a/src/rustc/middle/astencode.rs
+++ b/src/rustc/middle/astencode.rs
@@ -7,15 +7,14 @@ use syntax::visit;
 use syntax::ast_map;
 use syntax::ast_util;
 use syntax::codemap::span;
-use std::ebml2;
-use std::ebml2::Serializer;
-use std::ebml2::get_doc;
+use std::ebml;
+use std::ebml::{Serializer, get_doc};
 use std::map::HashMap;
-use std::serialization2;
-use std::serialization2::{Serializable,
-                          SerializerHelpers,
-                          DeserializerHelpers,
-                          deserialize};
+use std::serialization;
+use std::serialization::{Serializable,
+                         SerializerHelpers,
+                         DeserializerHelpers,
+                         deserialize};
 use middle::{ty, typeck};
 use middle::typeck::{method_origin, method_map_entry,
                      vtable_res,
@@ -74,7 +73,7 @@ trait tr {
 // Top-level methods.
 
 fn encode_inlined_item(ecx: @e::encode_ctxt,
-                       ebml_w: ebml2::Serializer,
+                       ebml_w: ebml::Serializer,
                        path: ast_map::path,
                        ii: ast::inlined_item,
                        maps: maps) {
@@ -100,14 +99,14 @@ fn decode_inlined_item(cdata: cstore::crate_metadata,
                        tcx: ty::ctxt,
                        maps: maps,
                        path: ast_map::path,
-                       par_doc: ebml2::Doc) -> Option<ast::inlined_item> {
+                       par_doc: ebml::Doc) -> Option<ast::inlined_item> {
     let dcx = @{cdata: cdata, tcx: tcx, maps: maps};
     match par_doc.opt_child(c::tag_ast) {
       None => None,
       Some(ast_doc) => {
         debug!("> Decoding inlined fn: %s::?",
                ast_map::path_to_str(path, tcx.sess.parse_sess.interner));
-        let ast_dsr = &ebml2::Deserializer(ast_doc);
+        let ast_dsr = &ebml::Deserializer(ast_doc);
         let from_id_range = deserialize(ast_dsr);
         let to_id_range = reserve_id_range(dcx.tcx.sess, from_id_range);
         let xcx = extended_decode_ctxt_(@{dcx: dcx,
@@ -185,7 +184,7 @@ trait def_id_serializer_helpers {
     fn emit_def_id(did: ast::def_id);
 }
 
-impl<S: serialization2::Serializer> S: def_id_serializer_helpers {
+impl<S: serialization::Serializer> S: def_id_serializer_helpers {
     fn emit_def_id(did: ast::def_id) {
         did.serialize(&self)
     }
@@ -195,7 +194,7 @@ trait def_id_deserializer_helpers {
     fn read_def_id(xcx: extended_decode_ctxt) -> ast::def_id;
 }
 
-impl<D: serialization2::Deserializer> D: def_id_deserializer_helpers {
+impl<D: serialization::Deserializer> D: def_id_deserializer_helpers {
 
     fn read_def_id(xcx: extended_decode_ctxt) -> ast::def_id {
         let did: ast::def_id = deserialize(&self);
@@ -218,7 +217,7 @@ impl<D: serialization2::Deserializer> D: def_id_deserializer_helpers {
 // 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: ebml2::Serializer, item: ast::inlined_item) {
+fn encode_ast(ebml_w: ebml::Serializer, item: ast::inlined_item) {
     do ebml_w.wr_tag(c::tag_tree as uint) {
         item.serialize(&ebml_w)
     }
@@ -278,9 +277,9 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
     }
 }
 
-fn decode_ast(par_doc: ebml2::Doc) -> ast::inlined_item {
+fn decode_ast(par_doc: ebml::Doc) -> ast::inlined_item {
     let chi_doc = par_doc[c::tag_tree as uint];
-    let d = &ebml2::Deserializer(chi_doc);
+    let d = &ebml::Deserializer(chi_doc);
     deserialize(d)
 }
 
@@ -332,12 +331,12 @@ fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
 // ______________________________________________________________________
 // Encoding and decoding of ast::def
 
-fn encode_def(ebml_w: ebml2::Serializer, def: ast::def) {
+fn encode_def(ebml_w: ebml::Serializer, def: ast::def) {
     def.serialize(&ebml_w)
 }
 
-fn decode_def(xcx: extended_decode_ctxt, doc: ebml2::Doc) -> ast::def {
-    let dsr = &ebml2::Deserializer(doc);
+fn decode_def(xcx: extended_decode_ctxt, doc: ebml::Doc) -> ast::def {
+    let dsr = &ebml::Deserializer(doc);
     let def: ast::def = deserialize(dsr);
     def.tr(xcx)
 }
@@ -423,7 +422,7 @@ impl ty::bound_region: tr {
 // ______________________________________________________________________
 // Encoding and decoding of freevar information
 
-fn encode_freevar_entry(ebml_w: ebml2::Serializer, fv: @freevar_entry) {
+fn encode_freevar_entry(ebml_w: ebml::Serializer, fv: @freevar_entry) {
     (*fv).serialize(&ebml_w)
 }
 
@@ -431,7 +430,7 @@ trait ebml_deserializer_helper {
     fn read_freevar_entry(xcx: extended_decode_ctxt) -> freevar_entry;
 }
 
-impl ebml2::Deserializer: ebml_deserializer_helper {
+impl ebml::Deserializer: ebml_deserializer_helper {
     fn read_freevar_entry(xcx: extended_decode_ctxt) -> freevar_entry {
         let fv: freevar_entry = deserialize(&self);
         fv.tr(xcx)
@@ -452,7 +451,7 @@ trait read_method_map_entry_helper {
 }
 
 fn serialize_method_map_entry(ecx: @e::encode_ctxt,
-                              ebml_w: ebml2::Serializer,
+                              ebml_w: ebml::Serializer,
                               mme: method_map_entry) {
     do ebml_w.emit_rec {
         do ebml_w.emit_field(~"self_arg", 0u) {
@@ -464,7 +463,7 @@ fn serialize_method_map_entry(ecx: @e::encode_ctxt,
     }
 }
 
-impl ebml2::Deserializer: read_method_map_entry_helper {
+impl ebml::Deserializer: read_method_map_entry_helper {
     fn read_method_map_entry(xcx: extended_decode_ctxt) -> method_map_entry {
         do self.read_rec {
             {self_arg:
@@ -503,7 +502,7 @@ impl method_origin: tr {
 // Encoding and decoding vtable_res
 
 fn encode_vtable_res(ecx: @e::encode_ctxt,
-                     ebml_w: ebml2::Serializer,
+                     ebml_w: ebml::Serializer,
                      dr: typeck::vtable_res) {
     // can't autogenerate this code because automatic serialization of
     // ty::t doesn't work, and there is no way (atm) to have
@@ -515,7 +514,7 @@ fn encode_vtable_res(ecx: @e::encode_ctxt,
 }
 
 fn encode_vtable_origin(ecx: @e::encode_ctxt,
-                      ebml_w: ebml2::Serializer,
+                      ebml_w: ebml::Serializer,
                       vtable_origin: typeck::vtable_origin) {
     do ebml_w.emit_enum(~"vtable_origin") {
         match vtable_origin {
@@ -562,7 +561,7 @@ trait vtable_deserialization_helpers {
     fn read_vtable_origin(xcx: extended_decode_ctxt) -> typeck::vtable_origin;
 }
 
-impl ebml2::Deserializer: vtable_deserialization_helpers {
+impl ebml::Deserializer: vtable_deserialization_helpers {
     fn read_vtable_res(xcx: extended_decode_ctxt) -> typeck::vtable_res {
         @self.read_to_vec(|| self.read_vtable_origin(xcx) )
     }
@@ -639,7 +638,7 @@ trait ebml_writer_helpers {
     fn emit_tpbt(ecx: @e::encode_ctxt, tpbt: ty::ty_param_bounds_and_ty);
 }
 
-impl ebml2::Serializer: ebml_writer_helpers {
+impl ebml::Serializer: ebml_writer_helpers {
     fn emit_ty(ecx: @e::encode_ctxt, ty: ty::t) {
         do self.emit_opaque {
             e::write_type(ecx, self, ty)
@@ -692,7 +691,7 @@ trait write_tag_and_id {
     fn id(id: ast::node_id);
 }
 
-impl ebml2::Serializer: write_tag_and_id {
+impl ebml::Serializer: write_tag_and_id {
     fn tag(tag_id: c::astencode_tag, f: fn()) {
         do self.wr_tag(tag_id as uint) { f() }
     }
@@ -704,7 +703,7 @@ impl ebml2::Serializer: write_tag_and_id {
 
 fn encode_side_tables_for_ii(ecx: @e::encode_ctxt,
                              maps: maps,
-                             ebml_w: ebml2::Serializer,
+                             ebml_w: ebml::Serializer,
                              ii: ast::inlined_item) {
     do ebml_w.wr_tag(c::tag_table as uint) {
         ast_util::visit_ids_for_inlined_item(
@@ -720,7 +719,7 @@ fn encode_side_tables_for_ii(ecx: @e::encode_ctxt,
 
 fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
                              maps: maps,
-                             ebml_w: ebml2::Serializer,
+                             ebml_w: ebml::Serializer,
                              id: ast::node_id) {
     let tcx = ecx.tcx;
 
@@ -849,13 +848,13 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
 
 trait doc_decoder_helpers {
     fn as_int() -> int;
-    fn opt_child(tag: c::astencode_tag) -> Option<ebml2::Doc>;
+    fn opt_child(tag: c::astencode_tag) -> Option<ebml::Doc>;
 }
 
-impl ebml2::Doc: doc_decoder_helpers {
-    fn as_int() -> int { ebml2::doc_as_u64(self) as int }
-    fn opt_child(tag: c::astencode_tag) -> Option<ebml2::Doc> {
-        ebml2::maybe_get_doc(self, tag as uint)
+impl ebml::Doc: doc_decoder_helpers {
+    fn as_int() -> int { ebml::doc_as_u64(self) as int }
+    fn opt_child(tag: c::astencode_tag) -> Option<ebml::Doc> {
+        ebml::maybe_get_doc(self, tag as uint)
     }
 }
 
@@ -868,7 +867,7 @@ trait ebml_deserializer_decoder_helpers {
                                 -> ty::ty_param_bounds_and_ty;
 }
 
-impl ebml2::Deserializer: ebml_deserializer_decoder_helpers {
+impl ebml::Deserializer: ebml_deserializer_decoder_helpers {
 
     fn read_arg(xcx: extended_decode_ctxt) -> ty::arg {
         do self.read_opaque |doc| {
@@ -923,10 +922,10 @@ impl ebml2::Deserializer: ebml_deserializer_decoder_helpers {
 }
 
 fn decode_side_tables(xcx: extended_decode_ctxt,
-                      ast_doc: ebml2::Doc) {
+                      ast_doc: ebml::Doc) {
     let dcx = xcx.dcx;
     let tbl_doc = ast_doc[c::tag_table as uint];
-    for ebml2::docs(tbl_doc) |tag, entry_doc| {
+    for ebml::docs(tbl_doc) |tag, entry_doc| {
         let id0 = entry_doc[c::tag_table_id as uint].as_int();
         let id = xcx.tr_id(id0);
 
@@ -940,7 +939,7 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
             dcx.tcx.legacy_boxed_traits.insert(id, ());
         } else {
             let val_doc = entry_doc[c::tag_table_val as uint];
-            let val_dsr = &ebml2::Deserializer(val_doc);
+            let val_dsr = &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);
@@ -993,16 +992,16 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
 // Testing of astencode_gen
 
 #[cfg(test)]
-fn encode_item_ast(ebml_w: ebml2::Serializer, item: @ast::item) {
+fn encode_item_ast(ebml_w: ebml::Serializer, item: @ast::item) {
     do ebml_w.wr_tag(c::tag_tree as uint) {
         (*item).serialize(&ebml_w)
     }
 }
 
 #[cfg(test)]
-fn decode_item_ast(par_doc: ebml2::Doc) -> @ast::item {
+fn decode_item_ast(par_doc: ebml::Doc) -> @ast::item {
     let chi_doc = par_doc[c::tag_tree as uint];
-    let d = &ebml2::Deserializer(chi_doc);
+    let d = &ebml::Deserializer(chi_doc);
     @deserialize(d)
 }
 
@@ -1029,17 +1028,17 @@ fn mk_ctxt() -> fake_ext_ctxt {
 #[cfg(test)]
 fn roundtrip(in_item: @ast::item) {
     let bytes = do io::with_bytes_writer |wr| {
-        let ebml_w = ebml2::Serializer(wr);
+        let ebml_w = ebml::Serializer(wr);
         encode_item_ast(ebml_w, in_item);
     };
-    let ebml_doc = ebml2::Doc(@bytes);
+    let ebml_doc = ebml::Doc(@bytes);
     let out_item = decode_item_ast(ebml_doc);
 
     let exp_str = do io::with_str_writer |w| {
-        in_item.serialize(&std::prettyprint2::Serializer(w))
+        in_item.serialize(&std::prettyprint::Serializer(w))
     };
     let out_str = do io::with_str_writer |w| {
-        out_item.serialize(&std::prettyprint2::Serializer(w))
+        out_item.serialize(&std::prettyprint::Serializer(w))
     };
 
     debug!("expected string: %s", exp_str);
diff --git a/src/rustc/middle/freevars.rs b/src/rustc/middle/freevars.rs
index d26b9566c97..28400b5455d 100644
--- a/src/rustc/middle/freevars.rs
+++ b/src/rustc/middle/freevars.rs
@@ -16,6 +16,8 @@ export has_freevars;
 
 // A vector of defs representing the free variables referred to in a function.
 // (The def_upvar will already have been stripped).
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 type freevar_entry = {
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index bbc3a06fb67..85f03e1f0b3 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -211,6 +211,8 @@ type method = {ident: ast::ident,
 
 type mt = {ty: t, mutbl: ast::mutability};
 
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 enum vstore {
@@ -271,6 +273,8 @@ enum ast_ty_to_ty_cache_entry {
 
 type opt_region_variance = Option<region_variance>;
 
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 enum region_variance { rv_covariant, rv_invariant, rv_contravariant }
@@ -289,6 +293,8 @@ impl region_variance : cmp::Eq {
     pure fn ne(other: &region_variance) -> bool { !self.eq(other) }
 }
 
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 type AutoAdjustment = {
@@ -296,6 +302,8 @@ type AutoAdjustment = {
     autoref: Option<AutoRef>
 };
 
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 type AutoRef = {
@@ -304,6 +312,8 @@ type AutoRef = {
     mutbl: ast::mutability
 };
 
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 enum AutoRefKind {
@@ -509,6 +519,8 @@ impl param_ty : to_bytes::IterBytes {
 
 
 /// Representation of regions:
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 enum region {
@@ -538,6 +550,8 @@ enum region {
     re_var(RegionVid)
 }
 
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 enum bound_region {
@@ -669,6 +683,8 @@ enum param_bound {
 enum TyVid = uint;
 enum IntVid = uint;
 enum FnVid = uint;
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 enum RegionVid = uint;
diff --git a/src/rustc/middle/typeck.rs b/src/rustc/middle/typeck.rs
index c2bd7f26bad..027a1d06742 100644
--- a/src/rustc/middle/typeck.rs
+++ b/src/rustc/middle/typeck.rs
@@ -75,6 +75,8 @@ export method_static, method_param, method_trait, method_self;
 export vtable_static, vtable_param, vtable_trait;
 export provided_methods_map;
 
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 enum method_origin {
@@ -93,6 +95,8 @@ enum method_origin {
 
 // details for a method invoked with a receiver whose type is a type parameter
 // with a bounded trait.
+#[auto_serialize]
+#[auto_deserialize]
 #[auto_serialize2]
 #[auto_deserialize2]
 type method_param = {