rustc_metadata: go back to not using the opaque format.

Author: eddyb

src/librustc_metadata/astencode.rs

@@ -14,9 +14,7 @@ use rustc::hir::map as ast_map;
 
 use rustc::hir::intravisit::{Visitor, IdRangeComputingVisitor, IdRange};
 
-use common as c;
-use cstore;
-
+use cstore::CrateMetadata;
 use decoder::DecodeContext;
 use encoder::EncodeContext;
 
@@ -28,60 +26,53 @@ use rustc::ty::{self, TyCtxt};
 
 use syntax::ast;
 
-use rbml::reader;
 use rbml;
 use rustc_serialize::{Decodable, Encodable};
 
 // ______________________________________________________________________
 // Top-level methods.
 
 pub fn encode_inlined_item(ecx: &mut EncodeContext, ii: InlinedItemRef) {
-    ecx.tag(c::tag_ast, |ecx| {
-        ecx.tag(c::tag_id_range, |ecx| {
-            let mut visitor = IdRangeComputingVisitor::new();
-            match ii {
-                InlinedItemRef::Item(_, i) => visitor.visit_item(i),
-                InlinedItemRef::TraitItem(_, ti) => visitor.visit_trait_item(ti),
-                InlinedItemRef::ImplItem(_, ii) => visitor.visit_impl_item(ii)
-            }
-            visitor.result().encode(&mut ecx.opaque()).unwrap()
-        });
+    ecx.tag(::common::tag_ast, |ecx| {
+        let mut visitor = IdRangeComputingVisitor::new();
+        match ii {
+            InlinedItemRef::Item(_, i) => visitor.visit_item(i),
+            InlinedItemRef::TraitItem(_, ti) => visitor.visit_trait_item(ti),
+            InlinedItemRef::ImplItem(_, ii) => visitor.visit_impl_item(ii)
+        }
+        visitor.result().encode(ecx).unwrap();
 
-        ecx.tag(c::tag_tree, |ecx| ii.encode(ecx).unwrap());
+        ii.encode(ecx).unwrap();
 
-        ecx.tag(c::tag_table, |ecx| {
-            let mut visitor = SideTableEncodingIdVisitor {
-                ecx: ecx
-            };
-            match ii {
-                InlinedItemRef::Item(_, i) => visitor.visit_item(i),
-                InlinedItemRef::TraitItem(_, ti) => visitor.visit_trait_item(ti),
-                InlinedItemRef::ImplItem(_, ii) => visitor.visit_impl_item(ii)
-            }
-        });
+        let mut visitor = SideTableEncodingIdVisitor {
+            ecx: ecx
+        };
+        match ii {
+            InlinedItemRef::Item(_, i) => visitor.visit_item(i),
+            InlinedItemRef::TraitItem(_, ti) => visitor.visit_trait_item(ti),
+            InlinedItemRef::ImplItem(_, ii) => visitor.visit_impl_item(ii)
+        }
     });
 }
 
 /// Decodes an item from its AST in the cdata's metadata and adds it to the
 /// ast-map.
-pub fn decode_inlined_item<'a, 'tcx>(cdata: &cstore::CrateMetadata,
+pub fn decode_inlined_item<'a, 'tcx>(cdata: &CrateMetadata,
                                      tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                      parent_def_path: ast_map::DefPath,
                                      parent_did: DefId,
                                      ast_doc: rbml::Doc,
                                      orig_did: DefId)
                                      -> &'tcx InlinedItem {
     debug!("> Decoding inlined fn: {:?}", tcx.item_path_str(orig_did));
-    let from_id_range = {
-        let decoder = &mut ast_doc.get(c::tag_id_range).opaque();
-        IdRange {
-            min: ast::NodeId::from_u32(u32::decode(decoder).unwrap()),
-            max: ast::NodeId::from_u32(u32::decode(decoder).unwrap())
-        }
-    };
-    let mut dcx = DecodeContext::new(tcx, cdata, from_id_range,
-                                     ast_doc.get(c::tag_tree));
-    let ii = InlinedItem::decode(&mut dcx).unwrap();
+    let dcx = &mut ast_doc.decoder();
+    dcx.tcx = Some(tcx);
+    dcx.cdata = Some(cdata);
+    dcx.from_id_range = IdRange::decode(dcx).unwrap();
+    let cnt = dcx.from_id_range.max.as_usize() - dcx.from_id_range.min.as_usize();
+    dcx.to_id_range.min = tcx.sess.reserve_node_ids(cnt);
+    dcx.to_id_range.max = ast::NodeId::new(dcx.to_id_range.min.as_usize() + cnt);
+    let ii = InlinedItem::decode(dcx).unwrap();
 
     let ii = ast_map::map_decoded_item(&tcx.map,
                                        parent_def_path,
@@ -97,7 +88,7 @@ pub fn decode_inlined_item<'a, 'tcx>(cdata: &cstore::CrateMetadata,
     let inlined_did = tcx.map.local_def_id(item_node_id);
     tcx.register_item_type(inlined_did, tcx.lookup_item_type(orig_did));
 
-    decode_side_tables(&mut dcx, ast_doc);
+    decode_side_tables(dcx, ast_doc);
 
     ii
 }
@@ -116,7 +107,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.end_tag().unwrap();
     }
 
-    fn id(&mut self, id: ast::NodeId) {
+    fn entry(&mut self, table: Table, id: ast::NodeId) {
+        table.encode(self).unwrap();
         id.encode(self).unwrap();
     }
 }
@@ -131,67 +123,67 @@ impl<'a, 'b, 'tcx, 'v> Visitor<'v> for SideTableEncodingIdVisitor<'a, 'b, 'tcx>
     }
 }
 
+#[derive(RustcEncodable, RustcDecodable, Debug)]
+enum Table {
+    Def,
+    NodeType,
+    ItemSubsts,
+    Freevars,
+    MethodMap,
+    Adjustment,
+    UpvarCaptureMap,
+    ConstQualif,
+    CastKind
+}
+
 fn encode_side_tables_for_id(ecx: &mut EncodeContext, id: ast::NodeId) {
     let tcx = ecx.tcx;
 
     debug!("Encoding side tables for id {}", id);
 
     if let Some(def) = tcx.expect_def_or_none(id) {
-        ecx.tag(c::tag_table_def, |ecx| {
-            ecx.id(id);
-            def.encode(ecx).unwrap();
-        })
+        ecx.entry(Table::Def, id);
+        def.encode(ecx).unwrap();
     }
 
     if let Some(ty) = tcx.node_types().get(&id) {
-        ecx.tag(c::tag_table_node_type, |ecx| {
-            ecx.id(id);
-            ty.encode(ecx).unwrap();
-        })
+        ecx.entry(Table::NodeType, id);
+        ty.encode(ecx).unwrap();
     }
 
     if let Some(item_substs) = tcx.tables.borrow().item_substs.get(&id) {
-        ecx.tag(c::tag_table_item_subst, |ecx| {
-            ecx.id(id);
-            item_substs.substs.encode(ecx).unwrap();
-        })
+        ecx.entry(Table::ItemSubsts, id);
+        item_substs.substs.encode(ecx).unwrap();
     }
 
     if let Some(fv) = tcx.freevars.borrow().get(&id) {
-        ecx.tag(c::tag_table_freevars, |ecx| {
-            ecx.id(id);
-            fv.encode(ecx).unwrap();
-        });
+        ecx.entry(Table::Freevars, id);
+        fv.encode(ecx).unwrap();
 
         for freevar in fv {
-            ecx.tag(c::tag_table_upvar_capture_map, |ecx| {
-                ecx.id(id);
-
-                let def_id = freevar.def.def_id();
-                let var_id = tcx.map.as_local_node_id(def_id).unwrap();
-                let upvar_id = ty::UpvarId {
-                    var_id: var_id,
-                    closure_expr_id: id
-                };
-                let upvar_capture = tcx.tables
-                                       .borrow()
-                                       .upvar_capture_map
-                                       .get(&upvar_id)
-                                       .unwrap()
-                                       .clone();
-                var_id.encode(ecx).unwrap();
-                upvar_capture.encode(ecx).unwrap();
-            })
+            ecx.entry(Table::UpvarCaptureMap, id);
+            let def_id = freevar.def.def_id();
+            let var_id = tcx.map.as_local_node_id(def_id).unwrap();
+            let upvar_id = ty::UpvarId {
+                var_id: var_id,
+                closure_expr_id: id
+            };
+            let upvar_capture = tcx.tables
+                                    .borrow()
+                                    .upvar_capture_map
+                                    .get(&upvar_id)
+                                    .unwrap()
+                                    .clone();
+            var_id.encode(ecx).unwrap();
+            upvar_capture.encode(ecx).unwrap();
         }
     }
 
     let method_call = ty::MethodCall::expr(id);
     if let Some(method) = tcx.tables.borrow().method_map.get(&method_call) {
-        ecx.tag(c::tag_table_method_map, |ecx| {
-            ecx.id(id);
-            method_call.autoderef.encode(ecx).unwrap();
-            method.encode(ecx).unwrap();
-        })
+        ecx.entry(Table::MethodMap, id);
+        method_call.autoderef.encode(ecx).unwrap();
+        method.encode(ecx).unwrap();
     }
 
     if let Some(adjustment) = tcx.tables.borrow().adjustments.get(&id) {
@@ -200,91 +192,79 @@ fn encode_side_tables_for_id(ecx: &mut EncodeContext, id: ast::NodeId) {
                 for autoderef in 0..adj.autoderefs {
                     let method_call = ty::MethodCall::autoderef(id, autoderef as u32);
                     if let Some(method) = tcx.tables.borrow().method_map.get(&method_call) {
-                        ecx.tag(c::tag_table_method_map, |ecx| {
-                            ecx.id(id);
-                            method_call.autoderef.encode(ecx).unwrap();
-                            method.encode(ecx).unwrap();
-                        })
+                        ecx.entry(Table::MethodMap, id);
+                        method_call.autoderef.encode(ecx).unwrap();
+                        method.encode(ecx).unwrap();
                     }
                 }
             }
             _ => {}
         }
 
-        ecx.tag(c::tag_table_adjustments, |ecx| {
-            ecx.id(id);
-            adjustment.encode(ecx).unwrap();
-        })
+        ecx.entry(Table::Adjustment, id);
+        adjustment.encode(ecx).unwrap();
     }
 
     if let Some(cast_kind) = tcx.cast_kinds.borrow().get(&id) {
-        ecx.tag(c::tag_table_cast_kinds, |ecx| {
-            ecx.id(id);
-            cast_kind.encode(ecx).unwrap()
-        })
+        ecx.entry(Table::CastKind, id);
+        cast_kind.encode(ecx).unwrap();
     }
 
     if let Some(qualif) = tcx.const_qualif_map.borrow().get(&id) {
-        ecx.tag(c::tag_table_const_qualif, |ecx| {
-            ecx.id(id);
-            qualif.encode(ecx).unwrap()
-        })
+        ecx.entry(Table::ConstQualif, id);
+        qualif.encode(ecx).unwrap();
     }
 }
 
-fn decode_side_tables<'a, 'tcx>(dcx: &mut DecodeContext<'a, 'tcx>,
-                                ast_doc: rbml::Doc<'a>) {
-    for (tag, entry_doc) in reader::docs(ast_doc.get(c::tag_table)) {
-        dcx.rbml_r = reader::Decoder::new(entry_doc);
+fn decode_side_tables(dcx: &mut DecodeContext, ast_doc: rbml::Doc) {
+    while dcx.position() < ast_doc.end {
+        let table = Decodable::decode(dcx).unwrap();
         let id = Decodable::decode(dcx).unwrap();
-        debug!("decode_side_tables: entry for id={}, tag=0x{:x}", id, tag);
-        match tag {
-            c::tag_table_def => {
+        debug!("decode_side_tables: entry for id={}, table={:?}", id, table);
+        match table {
+            Table::Def => {
                 let def = Decodable::decode(dcx).unwrap();
-                dcx.tcx.def_map.borrow_mut().insert(id, def::PathResolution::new(def));
+                dcx.tcx().def_map.borrow_mut().insert(id, def::PathResolution::new(def));
             }
-            c::tag_table_node_type => {
+            Table::NodeType => {
                 let ty = Decodable::decode(dcx).unwrap();
-                dcx.tcx.node_type_insert(id, ty);
+                dcx.tcx().node_type_insert(id, ty);
             }
-            c::tag_table_item_subst => {
+            Table::ItemSubsts => {
                 let item_substs = Decodable::decode(dcx).unwrap();
-                dcx.tcx.tables.borrow_mut().item_substs.insert(id, item_substs);
+                dcx.tcx().tables.borrow_mut().item_substs.insert(id, item_substs);
             }
-            c::tag_table_freevars => {
+            Table::Freevars => {
                 let fv_info = Decodable::decode(dcx).unwrap();
-                dcx.tcx.freevars.borrow_mut().insert(id, fv_info);
+                dcx.tcx().freevars.borrow_mut().insert(id, fv_info);
             }
-            c::tag_table_upvar_capture_map => {
+            Table::UpvarCaptureMap => {
                 let upvar_id = ty::UpvarId {
                     var_id: Decodable::decode(dcx).unwrap(),
                     closure_expr_id: id
                 };
                 let ub = Decodable::decode(dcx).unwrap();
-                dcx.tcx.tables.borrow_mut().upvar_capture_map.insert(upvar_id, ub);
+                dcx.tcx().tables.borrow_mut().upvar_capture_map.insert(upvar_id, ub);
             }
-            c::tag_table_method_map => {
+            Table::MethodMap => {
                 let method_call = ty::MethodCall {
                     expr_id: id,
                     autoderef: Decodable::decode(dcx).unwrap()
                 };
                 let method = Decodable::decode(dcx).unwrap();
-                dcx.tcx.tables.borrow_mut().method_map.insert(method_call, method);
+                dcx.tcx().tables.borrow_mut().method_map.insert(method_call, method);
             }
-            c::tag_table_adjustments => {
+            Table::Adjustment => {
                 let adj = Decodable::decode(dcx).unwrap();
-                dcx.tcx.tables.borrow_mut().adjustments.insert(id, adj);
+                dcx.tcx().tables.borrow_mut().adjustments.insert(id, adj);
             }
-            c::tag_table_cast_kinds => {
+            Table::CastKind => {
                 let cast_kind = Decodable::decode(dcx).unwrap();
-                dcx.tcx.cast_kinds.borrow_mut().insert(id, cast_kind);
+                dcx.tcx().cast_kinds.borrow_mut().insert(id, cast_kind);
             }
-            c::tag_table_const_qualif => {
+            Table::ConstQualif => {
                 let qualif = Decodable::decode(dcx).unwrap();
-                dcx.tcx.const_qualif_map.borrow_mut().insert(id, qualif);
-            }
-            _ => {
-                bug!("unknown tag found in side tables: 0x{:x}", tag);
+                dcx.tcx().const_qualif_map.borrow_mut().insert(id, qualif);
             }
         }
     }

src/librustc_metadata/common.rs

@@ -97,28 +97,11 @@ pub const tag_items_data_item_reexport_name: usize = 0x48;
 // used to encode crate_ctxt side tables
 pub const tag_ast: usize = 0x50;
 
-pub const tag_tree: usize = 0x51;
+// GAP 0x51
 
 pub const tag_mir: usize = 0x52;
 
-pub const tag_table: usize = 0x53;
-
-pub const tag_id_range: usize = 0x54;
-
-// GAP 0x55
-pub const tag_table_def: usize = 0x56;
-pub const tag_table_node_type: usize = 0x57;
-pub const tag_table_item_subst: usize = 0x58;
-pub const tag_table_freevars: usize = 0x59;
-// GAP 0x5a, 0x5b, 0x5c, 0x5d, 0x5e
-pub const tag_table_method_map: usize = 0x5f;
-// GAP 0x60
-pub const tag_table_adjustments: usize = 0x61;
-// GAP 0x62, 0x63, 0x64, 0x65
-pub const tag_table_upvar_capture_map: usize = 0x66;
-// GAP 0x67, 0x68
-pub const tag_table_const_qualif: usize = 0x69;
-pub const tag_table_cast_kinds: usize = 0x6a;
+// GAP 0x53...0x6a
 
 pub const tag_item_trait_item_sort: usize = 0x70;