diff --git a/src/librustc_metadata/astencode.rs b/src/librustc_metadata/astencode.rs
index f00c4b82a851..9d4ed84993f1 100644
--- a/src/librustc_metadata/astencode.rs
+++ b/src/librustc_metadata/astencode.rs
@@ -33,7 +33,7 @@ use rustc_serialize::{Decodable, Encodable};
 // Top-level methods.
 
 pub fn encode_inlined_item(ecx: &mut EncodeContext, ii: InlinedItemRef) {
-    ecx.tag(::common::tag_ast, |ecx| {
+    ecx.tag(::common::item_tag::ast, |ecx| {
         let mut visitor = IdRangeComputingVisitor::new();
         match ii {
             InlinedItemRef::Item(_, i) => visitor.visit_item(i),
diff --git a/src/librustc_metadata/common.rs b/src/librustc_metadata/common.rs
index 6df8c7de415a..04b9b7f7c671 100644
--- a/src/librustc_metadata/common.rs
+++ b/src/librustc_metadata/common.rs
@@ -35,164 +35,12 @@ pub enum Family {
     AssociatedConst,
 }
 
-// GAP 0x00...0x19
-
-pub const tag_items: usize = 0x100; // top-level only
-
-pub const tag_paths_data_name: usize = 0x20;
-
-pub const tag_def_index: usize = 0x21;
-
-pub const tag_items_data: usize = 0x22;
-
-pub const tag_items_data_item: usize = 0x23;
-
-pub const tag_items_data_item_family: usize = 0x24;
-
-pub const tag_items_data_item_type: usize = 0x25;
-
-// GAP 0x26, 0x27
-
-pub const tag_items_data_parent_item: usize = 0x28;
-
-pub const tag_items_data_item_is_tuple_struct_ctor: usize = 0x29;
-
-pub const tag_items_closure_kind: usize = 0x2a;
-pub const tag_items_closure_ty: usize = 0x2b;
-pub const tag_def_key: usize = 0x2c;
-
-// GAP 0x2d 0x34
-
-pub const tag_index: usize = 0x110; // top-level only
-pub const tag_xref_index: usize = 0x111; // top-level only
-pub const tag_xref_data: usize = 0x112; // top-level only
-pub const tag_attributes: usize = 0x101; // top-level only
-
-// The list of crates that this crate depends on
-pub const tag_crate_deps: usize = 0x102; // top-level only
-pub const tag_crate_hash: usize = 0x103; // top-level only
-pub const tag_crate_crate_name: usize = 0x104; // top-level only
-pub const tag_crate_disambiguator: usize = 0x113; // top-level only
-
-// GAP 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a
-
-pub const tag_item_trait_ref: usize = 0x3b;
-
-// discriminator value for variants
-pub const tag_disr_val: usize = 0x3c;
-
-// GAP 0x3d, 0x3e, 0x3f, 0x40
-
-pub const tag_item_fields: usize = 0x41;
-// GAP 0x42
-pub const tag_item_variances: usize = 0x43;
-// GAP 0x44
-pub const tag_item_trait_method_explicit_self: usize = 0x45;
-
-// GAP 0x46, 0x47, 0x48
-
-// used to encode crate_ctxt side tables
-pub const tag_ast: usize = 0x50;
-
-// GAP 0x51
-
-pub const tag_mir: usize = 0x52;
-
-// GAP 0x53...0x6a
-
-pub const tag_item_trait_item_has_body: usize = 0x70;
-
-pub const tag_crate_triple: usize = 0x105; // top-level only
-
-pub const tag_dylib_dependency_formats: usize = 0x106; // top-level only
-
-pub const tag_lang_items: usize = 0x107; // top-level only
-
-// GAP 0x73, 0x74, 0x75
-
-pub const tag_lang_items_missing: usize = 0x76; // top-level only
-
-// GAP 0x77
-
-pub const tag_items_data_item_visibility: usize = 0x78;
-pub const tag_items_data_item_inherent_impls: usize = 0x79;
-
-// GAP 0x7a
+// NB: increment this if you change the format of metadata such that
+// rustc_version can't be found.
+pub const metadata_encoding_version : &'static [u8] = &[b'r', b'u', b's', b't', 0, 0, 0, 2];
 
 // GAP 0x7c
-pub const tag_mod_children: usize = 0x7b;
-
-// GAP 0x108 // top-level only
-
-// GAP 0x7c
-
 // GAP 0x108
-pub const tag_impls: usize = 0x109; // top-level only
-
-// GAP 0x7d, 0x7e, 0x7f, 0x80, 0x81
-
-pub const tag_native_libraries: usize = 0x10a; // top-level only
-
-// GAP 0x82, 0x83, 0x84
-
-pub const tag_plugin_registrar_fn: usize = 0x10b; // top-level only
-
-pub const tag_method_argument_names: usize = 0x85;
-
-// GAP 0x86
-
-pub const tag_reachable_ids: usize = 0x10c; // top-level only
-
-// GAP 0x87
-
-pub const tag_items_data_item_stability: usize = 0x88;
-
-pub const tag_items_data_item_repr: usize = 0x89;
-
-// GAP 0x10d // top-level only
-
-// GAP 0x8a
-
-pub const tag_items_data_item_struct_ctor: usize = 0x8b;
-pub const tag_attribute_is_sugared_doc: usize = 0x8c;
-// GAP 0x8d
-pub const tag_items_data_region: usize = 0x8e;
-
-pub const tag_item_generics: usize = 0x8f;
-// GAP 0x90, 0x91, 0x92, 0x93, 0x94
-
-pub const tag_item_predicates: usize = 0x95;
-// GAP 0x96, 0x97, 0x98, 0x99
-
-pub const tag_unsafety: usize = 0x9a;
-
-pub const tag_polarity: usize = 0x9d;
-
-pub const tag_macro_defs: usize = 0x10e; // top-level only
-
-// GAP 0x9e, 0x9f
-
-pub const tag_paren_sugar: usize = 0xa0;
-
-pub const tag_codemap: usize = 0xa1;
-
-// GAP 0xa2
-
-pub const tag_item_super_predicates: usize = 0xa3;
-
-pub const tag_defaulted_trait: usize = 0xa4;
-
-pub const tag_impl_coerce_unsized_kind: usize = 0xa5;
-
-pub const tag_items_data_item_constness: usize = 0xa6;
-
-pub const tag_items_data_item_deprecation: usize = 0xa7;
-
-pub const tag_items_data_item_defaultness: usize = 0xa8;
-
-pub const tag_items_data_parent_impl: usize = 0xa9;
-
-pub const tag_rustc_version: usize = 0x10f;
 pub fn rustc_version() -> String {
     format!(
         "rustc {}",
@@ -200,13 +48,69 @@ pub fn rustc_version() -> String {
     )
 }
 
-pub const tag_panic_strategy: usize = 0x114;
+pub mod root_tag {
+    pub const rustc_version: usize = 0x10f;
+    pub const crate_deps: usize = 0x102;
+    pub const crate_hash: usize = 0x103;
+    pub const crate_crate_name: usize = 0x104;
+    pub const crate_disambiguator: usize = 0x113;
+    pub const items: usize = 0x100;
+    pub const index: usize = 0x110;
+    pub const xref_index: usize = 0x111;
+    pub const xref_data: usize = 0x112;
+    pub const crate_triple: usize = 0x105;
+    pub const dylib_dependency_formats: usize = 0x106;
+    pub const lang_items: usize = 0x107;
+    pub const lang_items_missing: usize = 0x76;
+    pub const impls: usize = 0x109;
+    pub const native_libraries: usize = 0x10a;
+    pub const plugin_registrar_fn: usize = 0x10b;
+    pub const panic_strategy: usize = 0x114;
+    pub const macro_derive_registrar: usize = 0x115;
+    pub const reachable_ids: usize = 0x10c;
+    pub const macro_defs: usize = 0x10e;
+    pub const codemap: usize = 0xa1;
+}
 
-pub const tag_macro_derive_registrar: usize = 0x115;
-
-// NB: increment this if you change the format of metadata such that
-// rustc_version can't be found.
-pub const metadata_encoding_version : &'static [u8] = &[b'r', b'u', b's', b't', 0, 0, 0, 2];
+pub mod item_tag {
+    pub const name: usize = 0x20;
+    pub const def_index: usize = 0x21;
+    pub const family: usize = 0x24;
+    pub const ty: usize = 0x25;
+    pub const parent_item: usize = 0x28;
+    pub const is_tuple_struct_ctor: usize = 0x29;
+    pub const closure_kind: usize = 0x2a;
+    pub const closure_ty: usize = 0x2b;
+    pub const def_key: usize = 0x2c;
+    pub const attributes: usize = 0x101;
+    pub const trait_ref: usize = 0x3b;
+    pub const disr_val: usize = 0x3c;
+    pub const fields: usize = 0x41;
+    pub const variances: usize = 0x43;
+    pub const trait_method_explicit_self: usize = 0x45;
+    pub const ast: usize = 0x50;
+    pub const mir: usize = 0x52;
+    pub const trait_item_has_body: usize = 0x70;
+    pub const visibility: usize = 0x78;
+    pub const inherent_impls: usize = 0x79;
+    pub const children: usize = 0x7b;
+    pub const method_argument_names: usize = 0x85;
+    pub const stability: usize = 0x88;
+    pub const repr: usize = 0x89;
+    pub const struct_ctor: usize = 0x8b;
+    pub const generics: usize = 0x8f;
+    pub const predicates: usize = 0x95;
+    pub const unsafety: usize = 0x9a;
+    pub const polarity: usize = 0x9d;
+    pub const paren_sugar: usize = 0xa0;
+    pub const super_predicates: usize = 0xa3;
+    pub const defaulted_trait: usize = 0xa4;
+    pub const impl_coerce_unsized_kind: usize = 0xa5;
+    pub const constness: usize = 0xa6;
+    pub const deprecation: usize = 0xa7;
+    pub const defaultness: usize = 0xa8;
+    pub const parent_impl: usize = 0xa9;
+}
 
 /// The shorthand encoding of `Ty` uses `TypeVariants`' variant `usize`
 /// and is offset by this value so it never matches a real variant.
diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs
index 8b87f0e718fb..662236be0f0d 100644
--- a/src/librustc_metadata/decoder.rs
+++ b/src/librustc_metadata/decoder.rs
@@ -324,53 +324,53 @@ impl CrateMetadata {
 }
 
 pub fn load_index(data: &[u8]) -> index::Index {
-    index::Index::from_rbml(rbml::Doc::new(data).get(tag_index))
+    index::Index::from_rbml(rbml::Doc::new(data).get(root_tag::index))
 }
 
 pub fn crate_rustc_version(data: &[u8]) -> Option<String> {
     let doc = rbml::Doc::new(data);
-    reader::maybe_get_doc(doc, tag_rustc_version).map(|s| {
+    reader::maybe_get_doc(doc, root_tag::rustc_version).map(|s| {
         str::from_utf8(&s.data[s.start..s.end]).unwrap().to_string()
     })
 }
 
 pub fn load_xrefs(data: &[u8]) -> index::DenseIndex {
-    let index = rbml::Doc::new(data).get(tag_xref_index);
+    let index = rbml::Doc::new(data).get(root_tag::xref_index);
     index::DenseIndex::from_buf(index.data, index.start, index.end)
 }
 
 // Go through each item in the metadata and create a map from that
 // item's def-key to the item's DefIndex.
 pub fn load_key_map(data: &[u8]) -> FnvHashMap<DefKey, DefIndex> {
-    rbml::Doc::new(data).get(tag_items).get(tag_items_data).children().map(|item_doc| {
+    rbml::Doc::new(data).get(root_tag::items).children().map(|item_doc| {
         // load def-key from item
         let key = item_def_key(item_doc);
 
         // load def-index from item
-        (key, item_doc.get(tag_def_index).decoder().decode())
+        (key, item_doc.get(item_tag::def_index).decoder().decode())
     }).collect()
 }
 
 fn item_family(item: rbml::Doc) -> Family {
-    item.get(tag_items_data_item_family).decoder().decode()
+    item.get(item_tag::family).decoder().decode()
 }
 
 fn item_visibility(item: rbml::Doc) -> ty::Visibility {
-    match reader::maybe_get_doc(item, tag_items_data_item_visibility) {
+    match reader::maybe_get_doc(item, item_tag::visibility) {
         None => ty::Visibility::Public,
         Some(visibility_doc) => visibility_doc.decoder().decode()
     }
 }
 
 fn item_defaultness(item: rbml::Doc) -> hir::Defaultness {
-    match reader::maybe_get_doc(item, tag_items_data_item_defaultness) {
+    match reader::maybe_get_doc(item, item_tag::defaultness) {
         None => hir::Defaultness::Default, // should occur only for default impls on traits
         Some(defaultness_doc) => defaultness_doc.decoder().decode()
     }
 }
 
 fn item_parent_item(cdata: Cmd, d: rbml::Doc) -> Option<DefId> {
-    reader::maybe_get_doc(d, tag_items_data_parent_item).map(|did| {
+    reader::maybe_get_doc(d, item_tag::parent_item).map(|did| {
         let mut dcx = did.decoder();
         dcx.cdata = Some(cdata);
         dcx.decode()
@@ -378,7 +378,7 @@ fn item_parent_item(cdata: Cmd, d: rbml::Doc) -> Option<DefId> {
 }
 
 fn item_require_parent_item(cdata: Cmd, d: rbml::Doc) -> DefId {
-    let mut dcx = d.get(tag_items_data_parent_item).decoder();
+    let mut dcx = d.get(item_tag::parent_item).decoder();
     dcx.cdata = Some(cdata);
     dcx.decode()
 }
@@ -386,17 +386,17 @@ fn item_require_parent_item(cdata: Cmd, d: rbml::Doc) -> DefId {
 fn item_def_id(d: rbml::Doc, cdata: Cmd) -> DefId {
     DefId {
         krate: cdata.cnum,
-        index: d.get(tag_def_index).decoder().decode()
+        index: d.get(item_tag::def_index).decoder().decode()
     }
 }
 
 fn doc_type<'a, 'tcx>(doc: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>, cdata: Cmd) -> Ty<'tcx> {
-    maybe_doc_type(doc, tcx, cdata).expect("missing tag_items_data_item_type")
+    maybe_doc_type(doc, tcx, cdata).expect("missing item_tag::ty")
 }
 
 fn maybe_doc_type<'a, 'tcx>(doc: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>, cdata: Cmd)
                             -> Option<Ty<'tcx>> {
-    reader::maybe_get_doc(doc, tag_items_data_item_type).map(|tp| {
+    reader::maybe_get_doc(doc, item_tag::ty).map(|tp| {
         let mut dcx = tp.decoder();
         dcx.tcx = Some(tcx);
         dcx.cdata = Some(cdata);
@@ -417,7 +417,7 @@ fn item_name(item: rbml::Doc) -> ast::Name {
 }
 
 fn maybe_item_name(item: rbml::Doc) -> Option<ast::Name> {
-    reader::maybe_get_doc(item, tag_paths_data_name).map(|name| {
+    reader::maybe_get_doc(item, item_tag::name).map(|name| {
         name.decoder().decode()
     })
 }
@@ -459,9 +459,9 @@ pub fn get_trait_def<'a, 'tcx>(cdata: Cmd,
 {
     let item_doc = cdata.lookup_item(item_id);
     let generics = doc_generics(item_doc, tcx, cdata);
-    let unsafety = item_doc.get(tag_unsafety).decoder().decode();
-    let paren_sugar = item_doc.get(tag_paren_sugar).decoder().decode();
-    let trait_ref = doc_trait_ref(item_doc.get(tag_item_trait_ref), tcx, cdata);
+    let unsafety = item_doc.get(item_tag::unsafety).decoder().decode();
+    let paren_sugar = item_doc.get(item_tag::paren_sugar).decoder().decode();
+    let trait_ref = doc_trait_ref(item_doc.get(item_tag::trait_ref), tcx, cdata);
     let def_path = def_path(cdata, item_id).unwrap();
 
     ty::TraitDef::new(unsafety, paren_sugar, generics, trait_ref,
@@ -481,12 +481,12 @@ pub fn get_adt_def<'a, 'tcx>(cdata: Cmd,
         }
     }
     fn get_enum_variants<'tcx>(cdata: Cmd, doc: rbml::Doc) -> Vec<ty::VariantDefData<'tcx, 'tcx>> {
-        let mut dcx = doc.get(tag_mod_children).decoder();
+        let mut dcx = doc.get(item_tag::children).decoder();
         dcx.cdata = Some(cdata);
 
         dcx.seq().map(|did: DefId| {
             let item = cdata.lookup_item(did.index);
-            let disr = item.get(tag_disr_val).decoder().decode();
+            let disr = item.get(item_tag::disr_val).decoder().decode();
             ty::VariantDefData {
                 did: did,
                 name: item_name(item),
@@ -497,7 +497,7 @@ pub fn get_adt_def<'a, 'tcx>(cdata: Cmd,
         }).collect()
     }
     fn get_variant_fields<'tcx>(cdata: Cmd, doc: rbml::Doc) -> Vec<ty::FieldDefData<'tcx, 'tcx>> {
-        let mut dcx = doc.get(tag_item_fields).decoder();
+        let mut dcx = doc.get(item_tag::fields).decoder();
         dcx.cdata = Some(cdata);
 
         dcx.seq().map(|did: DefId| {
@@ -531,7 +531,7 @@ pub fn get_adt_def<'a, 'tcx>(cdata: Cmd,
         }
         Struct(..) => {
             // Use separate constructor id for unit/tuple structs and reuse did for braced structs.
-            ctor_did = reader::maybe_get_doc(doc, tag_items_data_item_struct_ctor).map(|ctor_doc| {
+            ctor_did = reader::maybe_get_doc(doc, item_tag::struct_ctor).map(|ctor_doc| {
                 let mut dcx = ctor_doc.decoder();
                 dcx.cdata = Some(cdata);
                 dcx.decode()
@@ -595,7 +595,7 @@ pub fn get_predicates<'a, 'tcx>(cdata: Cmd,
                                 -> ty::GenericPredicates<'tcx>
 {
     let item_doc = cdata.lookup_item(item_id);
-    doc_predicates(item_doc, tcx, cdata, tag_item_predicates)
+    doc_predicates(item_doc, tcx, cdata, item_tag::predicates)
 }
 
 pub fn get_super_predicates<'a, 'tcx>(cdata: Cmd,
@@ -604,7 +604,7 @@ pub fn get_super_predicates<'a, 'tcx>(cdata: Cmd,
                                       -> ty::GenericPredicates<'tcx>
 {
     let item_doc = cdata.lookup_item(item_id);
-    doc_predicates(item_doc, tcx, cdata, tag_item_super_predicates)
+    doc_predicates(item_doc, tcx, cdata, item_tag::super_predicates)
 }
 
 pub fn get_generics<'a, 'tcx>(cdata: Cmd,
@@ -625,14 +625,14 @@ pub fn get_type<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>)
 
 pub fn get_stability(cdata: Cmd, id: DefIndex) -> Option<attr::Stability> {
     let item = cdata.lookup_item(id);
-    reader::maybe_get_doc(item, tag_items_data_item_stability).map(|doc| {
+    reader::maybe_get_doc(item, item_tag::stability).map(|doc| {
         doc.decoder().decode()
     })
 }
 
 pub fn get_deprecation(cdata: Cmd, id: DefIndex) -> Option<attr::Deprecation> {
     let item = cdata.lookup_item(id);
-    reader::maybe_get_doc(item, tag_items_data_item_deprecation).map(|doc| {
+    reader::maybe_get_doc(item, item_tag::deprecation).map(|doc| {
         doc.decoder().decode()
     })
 }
@@ -643,7 +643,7 @@ pub fn get_visibility(cdata: Cmd, id: DefIndex) -> ty::Visibility {
 
 pub fn get_parent_impl(cdata: Cmd, id: DefIndex) -> Option<DefId> {
     let item = cdata.lookup_item(id);
-    reader::maybe_get_doc(item, tag_items_data_parent_impl).map(|doc| {
+    reader::maybe_get_doc(item, item_tag::parent_impl).map(|doc| {
         let mut dcx = doc.decoder();
         dcx.cdata = Some(cdata);
         dcx.decode()
@@ -652,13 +652,13 @@ pub fn get_parent_impl(cdata: Cmd, id: DefIndex) -> Option<DefId> {
 
 pub fn get_repr_attrs(cdata: Cmd, id: DefIndex) -> Vec<attr::ReprAttr> {
     let item = cdata.lookup_item(id);
-    reader::maybe_get_doc(item, tag_items_data_item_repr).map_or(vec![], |doc| {
+    reader::maybe_get_doc(item, item_tag::repr).map_or(vec![], |doc| {
         doc.decoder().decode()
     })
 }
 
 pub fn get_impl_polarity(cdata: Cmd, id: DefIndex) -> hir::ImplPolarity {
-    cdata.lookup_item(id).get(tag_polarity).decoder().decode()
+    cdata.lookup_item(id).get(item_tag::polarity).decoder().decode()
 }
 
 pub fn get_custom_coerce_unsized_kind(
@@ -667,7 +667,7 @@ pub fn get_custom_coerce_unsized_kind(
     -> Option<ty::adjustment::CustomCoerceUnsized>
 {
     let item_doc = cdata.lookup_item(id);
-    reader::maybe_get_doc(item_doc, tag_impl_coerce_unsized_kind).map(|kind_doc| {
+    reader::maybe_get_doc(item_doc, item_tag::impl_coerce_unsized_kind).map(|kind_doc| {
         kind_doc.decoder().decode()
     })
 }
@@ -678,14 +678,14 @@ pub fn get_impl_trait<'a, 'tcx>(cdata: Cmd,
                                 -> Option<ty::TraitRef<'tcx>>
 {
     let item_doc = cdata.lookup_item(id);
-    reader::maybe_get_doc(item_doc, tag_item_trait_ref).map(|tp| {
+    reader::maybe_get_doc(item_doc, item_tag::trait_ref).map(|tp| {
         doc_trait_ref(tp, tcx, cdata)
     })
 }
 
 /// Iterates over the language items in the given crate.
 pub fn get_lang_items(cdata: Cmd) -> Vec<(DefIndex, usize)> {
-    rbml::Doc::new(cdata.data()).get(tag_lang_items).decoder().decode()
+    rbml::Doc::new(cdata.data()).get(root_tag::lang_items).decoder().decode()
 }
 
 
@@ -702,7 +702,7 @@ pub fn each_child_of_item<F, G>(cdata: Cmd, id: DefIndex,
         Some(item_doc) => item_doc,
     };
 
-    let mut dcx = match reader::maybe_get_doc(item_doc, tag_mod_children) {
+    let mut dcx = match reader::maybe_get_doc(item_doc, item_tag::children) {
         Some(doc) => doc.decoder(),
         None => return
     };
@@ -782,7 +782,7 @@ pub fn maybe_get_item_ast<'a, 'tcx>(cdata: Cmd, tcx: TyCtxt<'a, 'tcx, 'tcx>, id:
     };
     let mut parent_def_path = def_path(cdata, id).unwrap();
     parent_def_path.data.pop();
-    if let Some(ast_doc) = reader::maybe_get_doc(item_doc, tag_ast as usize) {
+    if let Some(ast_doc) = reader::maybe_get_doc(item_doc, item_tag::ast as usize) {
         let ii = decode_inlined_item(cdata,
                                      tcx,
                                      parent_def_path,
@@ -800,7 +800,7 @@ pub fn maybe_get_item_ast<'a, 'tcx>(cdata: Cmd, tcx: TyCtxt<'a, 'tcx, 'tcx>, id:
         let mut grandparent_def_path = parent_def_path;
         grandparent_def_path.data.pop();
         let parent_doc = cdata.lookup_item(parent_did.index);
-        if let Some(ast_doc) = reader::maybe_get_doc(parent_doc, tag_ast as usize) {
+        if let Some(ast_doc) = reader::maybe_get_doc(parent_doc, item_tag::ast as usize) {
             let ii = decode_inlined_item(cdata,
                                          tcx,
                                          grandparent_def_path,
@@ -817,7 +817,7 @@ pub fn maybe_get_item_ast<'a, 'tcx>(cdata: Cmd, tcx: TyCtxt<'a, 'tcx, 'tcx>, id:
 
 pub fn is_item_mir_available<'tcx>(cdata: Cmd, id: DefIndex) -> bool {
     if let Some(item_doc) = cdata.get_item(id) {
-        return reader::maybe_get_doc(item_doc, tag_mir as usize).is_some();
+        return reader::maybe_get_doc(item_doc, item_tag::mir as usize).is_some();
     }
 
     false
@@ -829,7 +829,7 @@ pub fn maybe_get_item_mir<'a, 'tcx>(cdata: Cmd,
                                     -> Option<Mir<'tcx>> {
     let item_doc = cdata.lookup_item(id);
 
-    reader::maybe_get_doc(item_doc, tag_mir).map(|mir_doc| {
+    reader::maybe_get_doc(item_doc, item_tag::mir).map(|mir_doc| {
         let mut dcx = mir_doc.decoder();
         dcx.tcx = Some(tcx);
         dcx.cdata = Some(cdata);
@@ -839,7 +839,7 @@ pub fn maybe_get_item_mir<'a, 'tcx>(cdata: Cmd,
 
 fn get_explicit_self<'a, 'tcx>(cdata: Cmd, item: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>)
                                -> ty::ExplicitSelfCategory<'tcx> {
-    let mut dcx = item.get(tag_item_trait_method_explicit_self).decoder();
+    let mut dcx = item.get(item_tag::trait_method_explicit_self).decoder();
     dcx.cdata = Some(cdata);
     dcx.tcx = Some(tcx);
 
@@ -881,12 +881,12 @@ pub fn get_impl_or_trait_item<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a
                 defaultness: defaultness,
                 def_id: def_id,
                 container: container,
-                has_value: item_doc.get(tag_item_trait_item_has_body).decoder().decode(),
+                has_value: item_doc.get(item_tag::trait_item_has_body).decoder().decode(),
             }))
         }
         Family::Method => {
             let generics = doc_generics(item_doc, tcx, cdata);
-            let predicates = doc_predicates(item_doc, tcx, cdata, tag_item_predicates);
+            let predicates = doc_predicates(item_doc, tcx, cdata, item_tag::predicates);
             let ity = tcx.lookup_item_type(def_id).ty;
             let fty = match ity.sty {
                 ty::TyFnDef(.., fty) => fty,
@@ -904,7 +904,7 @@ pub fn get_impl_or_trait_item<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a
                 explicit_self: explicit_self,
                 vis: vis,
                 defaultness: defaultness,
-                has_body: item_doc.get(tag_item_trait_item_has_body).decoder().decode(),
+                has_body: item_doc.get(item_tag::trait_item_has_body).decoder().decode(),
                 def_id: def_id,
                 container: container,
             }))
@@ -926,13 +926,13 @@ pub fn get_impl_or_trait_item<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a
 
 pub fn get_item_variances(cdata: Cmd, id: DefIndex) -> Vec<ty::Variance> {
     let item_doc = cdata.lookup_item(id);
-    item_doc.get(tag_item_variances).decoder().decode()
+    item_doc.get(item_tag::variances).decoder().decode()
 }
 
 pub fn get_struct_ctor_def_id(cdata: Cmd, node_id: DefIndex) -> Option<DefId>
 {
     let item = cdata.lookup_item(node_id);
-    reader::maybe_get_doc(item, tag_items_data_item_struct_ctor).map(|ctor_doc| {
+    reader::maybe_get_doc(item, item_tag::struct_ctor).map(|ctor_doc| {
         let mut dcx = ctor_doc.decoder();
         dcx.cdata = Some(cdata);
         dcx.decode()
@@ -946,7 +946,7 @@ pub fn get_tuple_struct_definition_if_ctor(cdata: Cmd,
     -> Option<DefId>
 {
     let item = cdata.lookup_item(node_id);
-    reader::maybe_get_doc(item, tag_items_data_item_is_tuple_struct_ctor).and_then(|doc| {
+    reader::maybe_get_doc(item, item_tag::is_tuple_struct_ctor).and_then(|doc| {
         if doc.decoder().decode() {
             Some(item_require_parent_item(cdata, item))
         } else {
@@ -968,7 +968,7 @@ pub fn get_item_attrs(cdata: Cmd,
 }
 
 pub fn get_struct_field_names(cdata: Cmd, id: DefIndex) -> Vec<ast::Name> {
-    let mut dcx = cdata.lookup_item(id).get(tag_item_fields).decoder();
+    let mut dcx = cdata.lookup_item(id).get(item_tag::fields).decoder();
     dcx.cdata = Some(cdata);
 
     dcx.seq().map(|did: DefId| {
@@ -977,7 +977,7 @@ pub fn get_struct_field_names(cdata: Cmd, id: DefIndex) -> Vec<ast::Name> {
 }
 
 fn get_attributes(md: rbml::Doc) -> Vec<ast::Attribute> {
-    reader::maybe_get_doc(md, tag_attributes).map_or(vec![], |attrs_doc| {
+    reader::maybe_get_doc(md, item_tag::attributes).map_or(vec![], |attrs_doc| {
         let mut attrs = attrs_doc.decoder().decode::<Vec<ast::Attribute>>();
 
         // Need new unique IDs: old thread-local IDs won't map to new threads.
@@ -998,7 +998,7 @@ pub struct CrateDep {
 }
 
 pub fn get_crate_deps(data: &[u8]) -> Vec<CrateDep> {
-    let dcx = rbml::Doc::new(data).get(tag_crate_deps).decoder();
+    let dcx = rbml::Doc::new(data).get(root_tag::crate_deps).decoder();
 
     dcx.seq().enumerate().map(|(crate_num, (name, hash, explicitly_linked))| {
         CrateDep {
@@ -1021,29 +1021,29 @@ fn list_crate_deps(data: &[u8], out: &mut io::Write) -> io::Result<()> {
 
 pub fn maybe_get_crate_hash(data: &[u8]) -> Option<Svh> {
     let cratedoc = rbml::Doc::new(data);
-    reader::maybe_get_doc(cratedoc, tag_crate_hash).map(|doc| {
+    reader::maybe_get_doc(cratedoc, root_tag::crate_hash).map(|doc| {
         doc.decoder().decode()
     })
 }
 
 pub fn get_crate_hash(data: &[u8]) -> Svh {
-    rbml::Doc::new(data).get(tag_crate_hash).decoder().decode()
+    rbml::Doc::new(data).get(root_tag::crate_hash).decoder().decode()
 }
 
 pub fn maybe_get_crate_name(data: &[u8]) -> Option<String> {
     let cratedoc = rbml::Doc::new(data);
-    reader::maybe_get_doc(cratedoc, tag_crate_crate_name).map(|doc| {
+    reader::maybe_get_doc(cratedoc, root_tag::crate_crate_name).map(|doc| {
         doc.decoder().decode()
     })
 }
 
 pub fn get_crate_disambiguator(data: &[u8]) -> String {
-    rbml::Doc::new(data).get(tag_crate_disambiguator).decoder().decode()
+    rbml::Doc::new(data).get(root_tag::crate_disambiguator).decoder().decode()
 }
 
 pub fn get_crate_triple(data: &[u8]) -> Option<String> {
     let cratedoc = rbml::Doc::new(data);
-    let triple_doc = reader::maybe_get_doc(cratedoc, tag_crate_triple);
+    let triple_doc = reader::maybe_get_doc(cratedoc, root_tag::crate_triple);
     triple_doc.map(|s| s.decoder().decode())
 }
 
@@ -1073,7 +1073,7 @@ pub fn each_inherent_implementation_for_type<F>(cdata: Cmd,
     where F: FnMut(DefId),
 {
     let item_doc = cdata.lookup_item(id);
-    let mut dcx = item_doc.get(tag_items_data_item_inherent_impls).decoder();
+    let mut dcx = item_doc.get(item_tag::inherent_impls).decoder();
     dcx.cdata = Some(cdata);
 
     for impl_def_id in dcx.seq() {
@@ -1095,7 +1095,7 @@ pub fn each_implementation_for_trait<F>(cdata: Cmd,
     };
 
     // FIXME(eddyb) Make this O(1) instead of O(n).
-    for trait_doc in rbml::Doc::new(cdata.data()).get(tag_impls).children() {
+    for trait_doc in rbml::Doc::new(cdata.data()).get(root_tag::impls).children() {
         let mut dcx = trait_doc.decoder();
         dcx.cdata = Some(cdata);
 
@@ -1128,18 +1128,18 @@ pub fn get_trait_of_item(cdata: Cmd, id: DefIndex) -> Option<DefId> {
 
 pub fn get_native_libraries(cdata: Cmd)
                             -> Vec<(cstore::NativeLibraryKind, String)> {
-    rbml::Doc::new(cdata.data()).get(tag_native_libraries).decoder().decode()
+    rbml::Doc::new(cdata.data()).get(root_tag::native_libraries).decoder().decode()
 }
 
 pub fn get_plugin_registrar_fn(data: &[u8]) -> Option<DefIndex> {
-    reader::maybe_get_doc(rbml::Doc::new(data), tag_plugin_registrar_fn)
+    reader::maybe_get_doc(rbml::Doc::new(data), root_tag::plugin_registrar_fn)
         .map(|doc| doc.decoder().decode())
 }
 
 pub fn each_exported_macro<F>(data: &[u8], mut f: F) where
     F: FnMut(ast::Name, Vec<ast::Attribute>, Span, String) -> bool,
 {
-    let dcx = rbml::Doc::new(data).get(tag_macro_defs).decoder();
+    let dcx = rbml::Doc::new(data).get(root_tag::macro_defs).decoder();
     for (name, attrs, span, body) in dcx.seq() {
         if !f(name, attrs, span, body) {
             break;
@@ -1148,14 +1148,14 @@ pub fn each_exported_macro<F>(data: &[u8], mut f: F) where
 }
 
 pub fn get_derive_registrar_fn(data: &[u8]) -> Option<DefIndex> {
-    reader::maybe_get_doc(rbml::Doc::new(data), tag_macro_derive_registrar)
+    reader::maybe_get_doc(rbml::Doc::new(data), root_tag::macro_derive_registrar)
         .map(|doc| doc.decoder().decode())
 }
 
 pub fn get_dylib_dependency_formats(cdata: Cmd)
     -> Vec<(CrateNum, LinkagePreference)>
 {
-    let dcx = rbml::Doc::new(cdata.data()).get(tag_dylib_dependency_formats).decoder();
+    let dcx = rbml::Doc::new(cdata.data()).get(root_tag::dylib_dependency_formats).decoder();
 
     dcx.seq::<Option<_>>().enumerate().flat_map(|(i, link)| {
         let cnum = CrateNum::new(i + 1);
@@ -1164,19 +1164,19 @@ pub fn get_dylib_dependency_formats(cdata: Cmd)
 }
 
 pub fn get_missing_lang_items(cdata: Cmd) -> Vec<lang_items::LangItem> {
-    rbml::Doc::new(cdata.data()).get(tag_lang_items_missing).decoder().decode()
+    rbml::Doc::new(cdata.data()).get(root_tag::lang_items_missing).decoder().decode()
 }
 
 pub fn get_method_arg_names(cdata: Cmd, id: DefIndex) -> Vec<String> {
     let method_doc = cdata.lookup_item(id);
-    match reader::maybe_get_doc(method_doc, tag_method_argument_names) {
+    match reader::maybe_get_doc(method_doc, item_tag::method_argument_names) {
         Some(args_doc) => args_doc.decoder().decode(),
         None => vec![],
     }
 }
 
 pub fn get_reachable_ids(cdata: Cmd) -> Vec<DefId> {
-    let dcx = rbml::Doc::new(cdata.data()).get(tag_reachable_ids).decoder();
+    let dcx = rbml::Doc::new(cdata.data()).get(root_tag::reachable_ids).decoder();
 
     dcx.seq().map(|index| {
         DefId {
@@ -1187,7 +1187,7 @@ pub fn get_reachable_ids(cdata: Cmd) -> Vec<DefId> {
 }
 
 pub fn is_const_fn(cdata: Cmd, id: DefIndex) -> bool {
-    match reader::maybe_get_doc(cdata.lookup_item(id), tag_items_data_item_constness) {
+    match reader::maybe_get_doc(cdata.lookup_item(id), item_tag::constness) {
         None => false,
         Some(doc) => {
             match doc.decoder().decode() {
@@ -1235,7 +1235,7 @@ fn doc_generics<'a, 'tcx>(base_doc: rbml::Doc,
                           cdata: Cmd)
                           -> &'tcx ty::Generics<'tcx>
 {
-    let mut dcx = base_doc.get(tag_item_generics).decoder();
+    let mut dcx = base_doc.get(item_tag::generics).decoder();
     dcx.tcx = Some(tcx);
     dcx.cdata = Some(cdata);
     tcx.alloc_generics(dcx.decode())
@@ -1268,7 +1268,7 @@ fn doc_predicates<'a, 'tcx>(base_doc: rbml::Doc,
 }
 
 pub fn is_defaulted_trait(cdata: Cmd, trait_id: DefIndex) -> bool {
-    cdata.lookup_item(trait_id).get(tag_defaulted_trait).decoder().decode()
+    cdata.lookup_item(trait_id).get(item_tag::defaulted_trait).decoder().decode()
 }
 
 pub fn is_default_impl(cdata: Cmd, impl_id: DefIndex) -> bool {
@@ -1276,17 +1276,17 @@ pub fn is_default_impl(cdata: Cmd, impl_id: DefIndex) -> bool {
 }
 
 pub fn get_imported_filemaps(metadata: &[u8]) -> Vec<syntax_pos::FileMap> {
-    rbml::Doc::new(metadata).get(tag_codemap).decoder().decode()
+    rbml::Doc::new(metadata).get(root_tag::codemap).decoder().decode()
 }
 
 pub fn closure_kind(cdata: Cmd, closure_id: DefIndex) -> ty::ClosureKind {
-    cdata.lookup_item(closure_id).get(tag_items_closure_kind).decoder().decode()
+    cdata.lookup_item(closure_id).get(item_tag::closure_kind).decoder().decode()
 }
 
 pub fn closure_ty<'a, 'tcx>(cdata: Cmd, closure_id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>)
                             -> ty::ClosureTy<'tcx> {
     let closure_doc = cdata.lookup_item(closure_id);
-    let closure_ty_doc = closure_doc.get(tag_items_closure_ty);
+    let closure_ty_doc = closure_doc.get(item_tag::closure_ty);
     let mut dcx = closure_ty_doc.decoder();
     dcx.tcx = Some(tcx);
     dcx.cdata = Some(cdata);
@@ -1300,18 +1300,9 @@ pub fn def_key(cdata: Cmd, id: DefIndex) -> hir_map::DefKey {
 }
 
 fn item_def_key(item_doc: rbml::Doc) -> hir_map::DefKey {
-    match reader::maybe_get_doc(item_doc, tag_def_key) {
-        Some(def_key_doc) => {
-            let simple_key = def_key_doc.decoder().decode();
-            let name = maybe_item_name(item_doc).map(|name| name.as_str());
-            def_key::recover_def_key(simple_key, name)
-        }
-        None => {
-            bug!("failed to find block with tag {:?} for item with family {:?}",
-                   tag_def_key,
-                   item_family(item_doc))
-        }
-    }
+    let simple_key = item_doc.get(item_tag::def_key).decoder().decode();
+    let name = maybe_item_name(item_doc).map(|name| name.as_str());
+    def_key::recover_def_key(simple_key, name)
 }
 
 // Returns the path leading to the thing with this `id`. Note that
@@ -1327,5 +1318,5 @@ pub fn def_path(cdata: Cmd, id: DefIndex) -> Option<hir_map::DefPath> {
 }
 
 pub fn get_panic_strategy(data: &[u8]) -> PanicStrategy {
-    rbml::Doc::new(data).get(tag_panic_strategy).decoder().decode()
+    rbml::Doc::new(data).get(root_tag::panic_strategy).decoder().decode()
 }
diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
index 326eb0fe9a3a..1e4c61e0b2e1 100644
--- a/src/librustc_metadata/encoder.rs
+++ b/src/librustc_metadata/encoder.rs
@@ -169,21 +169,21 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 }
 
 fn encode_name(ecx: &mut EncodeContext, name: Name) {
-    ecx.start_tag(tag_paths_data_name);
+    ecx.start_tag(item_tag::name);
     name.encode(ecx).unwrap();
     ecx.end_tag();
 }
 
 fn encode_def_id(ecx: &mut EncodeContext, def_id: DefId) {
     assert!(def_id.is_local());
-    ecx.start_tag(tag_def_index);
+    ecx.start_tag(item_tag::def_index);
     def_id.index.encode(ecx).unwrap();
     ecx.end_tag();
 }
 
 fn encode_def_key(ecx: &mut EncodeContext, key: DefKey) {
     let simple_key = def_key::simplify_def_key(key);
-    ecx.start_tag(tag_def_key);
+    ecx.start_tag(item_tag::def_key);
     simple_key.encode(ecx);
     ecx.end_tag();
 }
@@ -206,14 +206,14 @@ fn encode_trait_ref<'a, 'tcx>(ecx: &mut EncodeContext<'a, 'tcx>,
 
 // Item info table encoding
 fn encode_family(ecx: &mut EncodeContext, f: Family) {
-    ecx.start_tag(tag_items_data_item_family);
+    ecx.start_tag(item_tag::family);
     f.encode(ecx).unwrap();
     ecx.end_tag();
 }
 
 fn encode_item_variances(ecx: &mut EncodeContext, id: NodeId) {
     let v = ecx.tcx.item_variances(ecx.tcx.map.local_def_id(id));
-    ecx.start_tag(tag_item_variances);
+    ecx.start_tag(item_tag::variances);
     v.encode(ecx);
     ecx.end_tag();
 }
@@ -233,27 +233,27 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
     }
 
     fn encode_type(&mut self, typ: Ty<'tcx>) {
-        self.start_tag(tag_items_data_item_type);
+        self.start_tag(item_tag::ty);
         typ.encode(self).unwrap();
         self.end_tag();
     }
 
     fn encode_disr_val(&mut self,
                        disr_val: ty::Disr) {
-        self.start_tag(tag_disr_val);
+        self.start_tag(item_tag::disr_val);
         disr_val.to_u64_unchecked().encode(self).unwrap();
         self.end_tag();
     }
 
     fn encode_parent_item(&mut self, id: DefId) {
-        self.start_tag(tag_items_data_parent_item);
+        self.start_tag(item_tag::parent_item);
         id.encode(self).unwrap();
         self.end_tag();
     }
 
     fn encode_variant_fields(&mut self,
                              variant: ty::VariantDef) {
-        self.start_tag(tag_item_fields);
+        self.start_tag(item_tag::fields);
         self.seq(&variant.fields, |_, f| f.did);
         self.end_tag();
     }
@@ -321,7 +321,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         debug!("(encoding info for module) encoding info for module ID {}", id);
 
         // Encode info about all the module children.
-        self.start_tag(tag_mod_children);
+        self.start_tag(item_tag::children);
         self.seq(&md.item_ids, |_, item_id| {
             tcx.map.local_def_id(item_id.id)
         });
@@ -358,7 +358,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         } else {
             ty::Visibility::PrivateExternal
         };
-        self.start_tag(tag_items_data_item_visibility);
+        self.start_tag(item_tag::visibility);
         vis.encode(self).unwrap();
         self.end_tag();
     }
@@ -381,13 +381,13 @@ impl HasVisibility for ty::Visibility {
 }
 
 fn encode_constness(ecx: &mut EncodeContext, constness: hir::Constness) {
-    ecx.start_tag(tag_items_data_item_constness);
+    ecx.start_tag(item_tag::constness);
     constness.encode(ecx).unwrap();
     ecx.end_tag();
 }
 
 fn encode_defaultness(ecx: &mut EncodeContext, defaultness: hir::Defaultness) {
-    ecx.start_tag(tag_items_data_item_defaultness);
+    ecx.start_tag(item_tag::defaultness);
     defaultness.encode(ecx).unwrap();
     ecx.end_tag();
 }
@@ -463,7 +463,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         // definition, but without this there is no way for them
         // to tell that they actually have a ctor rather than a
         // normal function
-        self.start_tag(tag_items_data_item_is_tuple_struct_ctor);
+        self.start_tag(item_tag::is_tuple_struct_ctor);
         true.encode(self).unwrap();
         self.end_tag();
     }
@@ -472,10 +472,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                        generics: &ty::Generics<'tcx>,
                        predicates: &ty::GenericPredicates<'tcx>)
     {
-        self.start_tag(tag_item_generics);
+        self.start_tag(item_tag::generics);
         generics.encode(self).unwrap();
         self.end_tag();
-        self.encode_predicates(predicates, tag_item_predicates);
+        self.encode_predicates(predicates, item_tag::predicates);
     }
 
     fn encode_predicates(&mut self,
@@ -495,7 +495,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.encode_generics(&method_ty.generics, &method_ty.predicates);
         self.encode_visibility(method_ty.vis);
 
-        self.start_tag(tag_item_trait_method_explicit_self);
+        self.start_tag(item_tag::trait_method_explicit_self);
         method_ty.explicit_self.encode(self).unwrap();
         self.end_tag();
 
@@ -541,7 +541,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         encode_attributes(self, &trait_item.attrs);
         match trait_item.node {
             hir::ConstTraitItem(_, ref default) => {
-                self.start_tag(tag_item_trait_item_has_body);
+                self.start_tag(item_tag::trait_item_has_body);
                 default.is_some().encode(self).unwrap();
                 self.end_tag();
 
@@ -550,7 +550,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 self.encode_mir(item_def_id);
             }
             hir::MethodTraitItem(ref sig, ref body) => {
-                self.start_tag(tag_item_trait_item_has_body);
+                self.start_tag(item_tag::trait_item_has_body);
                 body.is_some().encode(self).unwrap();
                 self.end_tag();
 
@@ -600,7 +600,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
         self.encode_parent_item(tcx.map.local_def_id(parent_id));
 
-        self.start_tag(tag_item_trait_item_has_body);
+        self.start_tag(item_tag::trait_item_has_body);
         true.encode(self).unwrap();
         self.end_tag();
 
@@ -632,7 +632,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.encode_method_ty_fields(m);
         self.encode_parent_item(tcx.map.local_def_id(parent_id));
 
-        self.start_tag(tag_item_trait_item_has_body);
+        self.start_tag(item_tag::trait_item_has_body);
         true.encode(self).unwrap();
         self.end_tag();
 
@@ -697,7 +697,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
     fn encode_method_argument_names(&mut self,
                                     decl: &hir::FnDecl) {
-        self.start_tag(tag_method_argument_names);
+        self.start_tag(item_tag::method_argument_names);
 
         self.seq(&decl.inputs, |_, arg| {
             if let PatKind::Binding(_, ref path1, _) = arg.pat.node {
@@ -717,14 +717,14 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             repr_attrs.extend(attr::find_repr_attrs(self.tcx.sess.diagnostic(),
                                                     attr));
         }
-        self.start_tag(tag_items_data_item_repr);
+        self.start_tag(item_tag::repr);
         repr_attrs.encode(self);
         self.end_tag();
     }
 
     fn encode_mir(&mut self, def_id: DefId) {
         if let Some(mir) = self.mir_map.map.get(&def_id) {
-            self.start_tag(tag_mir as usize);
+            self.start_tag(item_tag::mir as usize);
             mir.encode(self);
             self.end_tag();
         }
@@ -734,7 +734,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 // Encodes the inherent implementations of a structure, enumeration, or trait.
 fn encode_inherent_implementations(ecx: &mut EncodeContext,
                                    def_id: DefId) {
-    ecx.start_tag(tag_items_data_item_inherent_impls);
+    ecx.start_tag(item_tag::inherent_impls);
     match ecx.tcx.inherent_impls.borrow().get(&def_id) {
         None => <[DefId]>::encode(&[], ecx).unwrap(),
         Some(implementations) => implementations.encode(ecx).unwrap()
@@ -744,7 +744,7 @@ fn encode_inherent_implementations(ecx: &mut EncodeContext,
 
 fn encode_stability(ecx: &mut EncodeContext, stab_opt: Option<&attr::Stability>) {
     stab_opt.map(|stab| {
-        ecx.start_tag(tag_items_data_item_stability);
+        ecx.start_tag(item_tag::stability);
         stab.encode(ecx).unwrap();
         ecx.end_tag();
     });
@@ -752,7 +752,7 @@ fn encode_stability(ecx: &mut EncodeContext, stab_opt: Option<&attr::Stability>)
 
 fn encode_deprecation(ecx: &mut EncodeContext, depr_opt: Option<attr::Deprecation>) {
     depr_opt.map(|depr| {
-        ecx.start_tag(tag_items_data_item_deprecation);
+        ecx.start_tag(item_tag::deprecation);
         depr.encode(ecx).unwrap();
         ecx.end_tag();
     });
@@ -772,7 +772,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         let mut sorted_xrefs: Vec<_> = xrefs.into_iter().collect();
         sorted_xrefs.sort_by_key(|&(_, id)| id);
 
-        self.start_tag(tag_xref_data);
+        self.start_tag(root_tag::xref_data);
         for (xref, id) in sorted_xrefs.into_iter() {
             xref_positions[id as usize] = self.mark_stable_position() as u32;
             match xref {
@@ -782,7 +782,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.mark_stable_position();
         self.end_tag();
 
-        self.start_tag(tag_xref_index);
+        self.start_tag(root_tag::xref_index);
         index::write_dense_index(xref_positions, &mut self.opaque.cursor);
         self.end_tag();
     }
@@ -857,7 +857,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 encode_name(self, item.name);
 
                 // Encode all the items in self module.
-                self.start_tag(tag_mod_children);
+                self.start_tag(item_tag::children);
                 self.seq(&fm.items, |_, foreign_item| {
                     tcx.map.local_def_id(foreign_item.id)
                 });
@@ -886,7 +886,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 encode_attributes(self, &item.attrs);
                 self.encode_repr_attrs(&item.attrs);
 
-                self.start_tag(tag_mod_children);
+                self.start_tag(item_tag::children);
                 self.seq(&enum_definition.variants, |_, v| {
                     tcx.map.local_def_id(v.node.data.id())
                 });
@@ -928,7 +928,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
                 if !struct_def.is_struct() {
                     let ctor_did = tcx.map.local_def_id(struct_def.id());
-                    self.start_tag(tag_items_data_item_struct_ctor);
+                    self.start_tag(item_tag::struct_ctor);
                     ctor_did.encode(self).unwrap();
                     self.end_tag();
                 }
@@ -966,7 +966,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 encode_name(self, item.name);
 
                 let trait_ref = tcx.impl_trait_ref(tcx.map.local_def_id(item.id)).unwrap();
-                encode_trait_ref(self, trait_ref, tag_item_trait_ref);
+                encode_trait_ref(self, trait_ref, item_tag::trait_ref);
             }
             hir::ItemImpl(_, polarity, ..) => {
                 encode_def_id_and_key(self, def_id);
@@ -975,7 +975,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 encode_name(self, item.name);
                 encode_attributes(self, &item.attrs);
 
-                self.start_tag(tag_polarity);
+                self.start_tag(item_tag::polarity);
                 polarity.encode(self).unwrap();
                 self.end_tag();
 
@@ -985,21 +985,21 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                        .get(&tcx.map.local_def_id(item.id))
                 {
                     Some(&kind) => {
-                        self.start_tag(tag_impl_coerce_unsized_kind);
+                        self.start_tag(item_tag::impl_coerce_unsized_kind);
                         kind.encode(self);
                         self.end_tag();
                     }
                     None => {}
                 }
 
-                self.start_tag(tag_mod_children);
+                self.start_tag(item_tag::children);
                 tcx.impl_or_trait_items(def_id).encode(self).unwrap();
                 <[def::Export]>::encode(&[], self).unwrap();
                 self.end_tag();
 
                 let did = tcx.map.local_def_id(item.id);
                 if let Some(trait_ref) = tcx.impl_trait_ref(did) {
-                    encode_trait_ref(self, trait_ref, tag_item_trait_ref);
+                    encode_trait_ref(self, trait_ref, item_tag::trait_ref);
 
                     let trait_def = tcx.lookup_trait_def(trait_ref.def_id);
                     let parent = trait_def.ancestors(did)
@@ -1011,7 +1011,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                                               _ => None,
                                           });
                     parent.map(|parent| {
-                        self.start_tag(tag_items_data_parent_impl);
+                        self.start_tag(item_tag::parent_impl);
                         parent.encode(self).unwrap();
                         self.end_tag();
                     });
@@ -1026,29 +1026,29 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 let trait_def = tcx.lookup_trait_def(def_id);
                 let trait_predicates = tcx.lookup_predicates(def_id);
 
-                self.start_tag(tag_unsafety);
+                self.start_tag(item_tag::unsafety);
                 trait_def.unsafety.encode(self).unwrap();
                 self.end_tag();
 
-                self.start_tag(tag_paren_sugar);
+                self.start_tag(item_tag::paren_sugar);
                 trait_def.paren_sugar.encode(self).unwrap();
                 self.end_tag();
 
-                self.start_tag(tag_defaulted_trait);
+                self.start_tag(item_tag::defaulted_trait);
                 tcx.trait_has_default_impl(def_id).encode(self).unwrap();
                 self.end_tag();
 
                 self.encode_generics(&trait_def.generics, &trait_predicates);
                 self.encode_predicates(&tcx.lookup_super_predicates(def_id),
-                                       tag_item_super_predicates);
-                encode_trait_ref(self, trait_def.trait_ref, tag_item_trait_ref);
+                                       item_tag::super_predicates);
+                encode_trait_ref(self, trait_def.trait_ref, item_tag::trait_ref);
                 encode_name(self, item.name);
                 encode_attributes(self, &item.attrs);
                 self.encode_visibility(vis);
                 encode_stability(self, stab);
                 encode_deprecation(self, depr);
 
-                self.start_tag(tag_mod_children);
+                self.start_tag(item_tag::children);
                 tcx.impl_or_trait_items(def_id).encode(self).unwrap();
                 <[def::Export]>::encode(&[], self).unwrap();
                 self.end_tag();
@@ -1276,11 +1276,11 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         encode_def_id_and_key(self, def_id);
         encode_name(self, syntax::parse::token::intern("<closure>"));
 
-        self.start_tag(tag_items_closure_ty);
+        self.start_tag(item_tag::closure_ty);
         tcx.tables.borrow().closure_tys[&def_id].encode(self).unwrap();
         self.end_tag();
 
-        self.start_tag(tag_items_closure_kind);
+        self.start_tag(item_tag::closure_kind);
         tcx.closure_kind(def_id).encode(self).unwrap();
         self.end_tag();
 
@@ -1292,7 +1292,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 fn encode_info_for_items(ecx: &mut EncodeContext) -> IndexData {
     let krate = ecx.tcx.map.krate();
 
-    ecx.start_tag(tag_items_data);
+    ecx.start_tag(root_tag::items);
 
     let items = {
         let mut index = IndexBuilder::new(ecx);
@@ -1315,13 +1315,13 @@ fn encode_info_for_items(ecx: &mut EncodeContext) -> IndexData {
 }
 
 fn encode_item_index(ecx: &mut EncodeContext, index: IndexData) {
-    ecx.start_tag(tag_index);
+    ecx.start_tag(root_tag::index);
     index.write_index(&mut ecx.opaque.cursor);
     ecx.end_tag();
 }
 
 fn encode_attributes(ecx: &mut EncodeContext, attrs: &[ast::Attribute]) {
-    ecx.start_tag(tag_attributes);
+    ecx.start_tag(item_tag::attributes);
     attrs.encode(ecx).unwrap();
     ecx.end_tag();
 }
@@ -1352,7 +1352,7 @@ fn encode_crate_deps(ecx: &mut EncodeContext, cstore: &cstore::CStore) {
     // the assumption that they are numbered 1 to n.
     // FIXME (#2166): This is not nearly enough to support correct versioning
     // but is enough to get transitive crate dependencies working.
-    ecx.start_tag(tag_crate_deps);
+    ecx.start_tag(root_tag::crate_deps);
     ecx.seq(&get_ordered_deps(cstore), |_, &(_, ref dep)| {
         (dep.name(), decoder::get_crate_hash(dep.data()),
          dep.explicitly_linked.get())
@@ -1376,11 +1376,11 @@ fn encode_lang_items(ecx: &mut EncodeContext) {
     let count = lang_items().count();
     let mut lang_items = lang_items();
 
-    ecx.start_tag(tag_lang_items);
+    ecx.start_tag(root_tag::lang_items);
     ecx.seq(0..count, |_, _| lang_items.next().unwrap());
     ecx.end_tag();
 
-    ecx.start_tag(tag_lang_items_missing);
+    ecx.start_tag(root_tag::lang_items_missing);
     tcx.lang_items.missing.encode(ecx).unwrap();
     ecx.end_tag();
 }
@@ -1401,7 +1401,7 @@ fn encode_native_libraries(ecx: &mut EncodeContext) {
     let count = libs().count();
     let mut libs = libs();
 
-    ecx.start_tag(tag_native_libraries);
+    ecx.start_tag(root_tag::native_libraries);
     ecx.seq(0..count, |_, _| libs.next().unwrap());
     ecx.end_tag();
 }
@@ -1410,7 +1410,7 @@ fn encode_plugin_registrar_fn(ecx: &mut EncodeContext) {
     match ecx.tcx.sess.plugin_registrar_fn.get() {
         Some(id) => {
             let def_id = ecx.tcx.map.local_def_id(id);
-            ecx.start_tag(tag_plugin_registrar_fn);
+            ecx.start_tag(root_tag::plugin_registrar_fn);
             def_id.index.encode(ecx).unwrap();
             ecx.end_tag();
         }
@@ -1434,7 +1434,7 @@ fn encode_codemap(ecx: &mut EncodeContext) {
     let count = filemaps().count();
     let mut filemaps = filemaps();
 
-    ecx.start_tag(tag_codemap);
+    ecx.start_tag(root_tag::codemap);
     ecx.seq(0..count, |_, _| filemaps.next().unwrap());
     ecx.end_tag();
 }
@@ -1442,7 +1442,7 @@ fn encode_codemap(ecx: &mut EncodeContext) {
 /// Serialize the text of the exported macros
 fn encode_macro_defs(ecx: &mut EncodeContext) {
     let tcx = ecx.tcx;
-    ecx.start_tag(tag_macro_defs);
+    ecx.start_tag(root_tag::macro_defs);
     ecx.seq(&tcx.map.krate().exported_macros, |_, def| {
         let body = ::syntax::print::pprust::tts_to_string(&def.body);
         (def.name, &def.attrs, def.span, body)
@@ -1453,7 +1453,7 @@ fn encode_macro_defs(ecx: &mut EncodeContext) {
         let id = ecx.tcx.sess.derive_registrar_fn.get().unwrap();
         let did = ecx.tcx.map.local_def_id(id);
 
-        ecx.start_tag(tag_macro_derive_registrar);
+        ecx.start_tag(root_tag::macro_derive_registrar);
         did.index.encode(ecx).unwrap();
         ecx.end_tag();
     }
@@ -1485,7 +1485,7 @@ fn encode_impls(ecx: &mut EncodeContext) {
     };
     ecx.tcx.map.krate().visit_all_items(&mut visitor);
 
-    ecx.start_tag(tag_impls);
+    ecx.start_tag(root_tag::impls);
     for (trait_def_id, trait_impls) in visitor.impls {
         // FIXME(eddyb) Avoid wrapping the entries in docs.
         ecx.start_tag(0);
@@ -1503,7 +1503,7 @@ fn encode_impls(ecx: &mut EncodeContext) {
 // symbol associated with them (they weren't translated) or if they're an FFI
 // definition (as that's not defined in this crate).
 fn encode_reachable(ecx: &mut EncodeContext) {
-    ecx.start_tag(tag_reachable_ids);
+    ecx.start_tag(root_tag::reachable_ids);
 
     let reachable = ecx.reachable;
     ecx.seq(reachable, |ecx, &id| ecx.tcx.map.local_def_id(id).index);
@@ -1512,7 +1512,7 @@ fn encode_reachable(ecx: &mut EncodeContext) {
 }
 
 fn encode_dylib_dependency_formats(ecx: &mut EncodeContext) {
-    ecx.start_tag(tag_dylib_dependency_formats);
+    ecx.start_tag(root_tag::dylib_dependency_formats);
     match ecx.tcx.sess.dependency_formats.borrow().get(&config::CrateTypeDylib) {
         Some(arr) => {
             ecx.seq(arr, |_, slot| {
@@ -1596,30 +1596,30 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 }
 
 fn encode_metadata_inner(ecx: &mut EncodeContext) {
-    ecx.wr_tagged_str(tag_rustc_version, &rustc_version());
+    ecx.wr_tagged_str(root_tag::rustc_version, &rustc_version());
 
     let tcx = ecx.tcx;
     let link_meta = ecx.link_meta;
 
-    ecx.start_tag(tag_crate_crate_name);
+    ecx.start_tag(root_tag::crate_crate_name);
     link_meta.crate_name.encode(ecx).unwrap();
     ecx.end_tag();
 
-    ecx.start_tag(tag_crate_triple);
+    ecx.start_tag(root_tag::crate_triple);
     tcx.sess.opts.target_triple.encode(ecx).unwrap();
     ecx.end_tag();
 
-    ecx.start_tag(tag_crate_hash);
+    ecx.start_tag(root_tag::crate_hash);
     link_meta.crate_hash.encode(ecx).unwrap();
     ecx.end_tag();
 
-    ecx.start_tag(tag_crate_disambiguator);
+    ecx.start_tag(root_tag::crate_disambiguator);
     tcx.sess.local_crate_disambiguator().encode(ecx).unwrap();
     ecx.end_tag();
 
     encode_dylib_dependency_formats(ecx);
 
-    ecx.start_tag(tag_panic_strategy);
+    ecx.start_tag(root_tag::panic_strategy);
     ecx.tcx.sess.opts.cg.panic.encode(ecx);
     ecx.end_tag();
 
@@ -1663,11 +1663,9 @@ fn encode_metadata_inner(ecx: &mut EncodeContext) {
     let reachable_bytes = ecx.position() - i;
 
     // Encode and index the items.
-    ecx.start_tag(tag_items);
     i = ecx.position();
     let items = encode_info_for_items(ecx);
     let item_bytes = ecx.position() - i;
-    ecx.end_tag();
 
     i = ecx.position();
     encode_item_index(ecx, items);
diff --git a/src/librustc_metadata/index_builder.rs b/src/librustc_metadata/index_builder.rs
index 2cfa6f8d5d11..372577e21f11 100644
--- a/src/librustc_metadata/index_builder.rs
+++ b/src/librustc_metadata/index_builder.rs
@@ -55,7 +55,6 @@
 //! give a callback fn, rather than taking a closure: it allows us to
 //! easily control precisely what data is given to that fn.
 
-use common::tag_items_data_item;
 use encoder::EncodeContext;
 use index::IndexData;
 use rustc::dep_graph::DepNode;
@@ -120,7 +119,8 @@ impl<'a, 'b, 'tcx> IndexBuilder<'a, 'b, 'tcx> {
         let position = self.ecx.mark_stable_position();
         self.items.record(id, position);
         let _task = self.tcx.dep_graph.in_task(DepNode::MetaData(id));
-        self.ecx.start_tag(tag_items_data_item).unwrap();
+        // FIXME(eddyb) Avoid wrapping the entries in docs.
+        self.ecx.start_tag(0).unwrap();
         data.read(self.tcx);
         op(&mut self.ecx, data);
         self.ecx.end_tag().unwrap();