rustc_metadata: encode miscellaneous information opaquely.

4 files changed, 32 insertions, 59 deletions

diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs
index ecddab0d060..b808aad1436 100644
--- a/src/librustc_metadata/decoder.rs
+++ b/src/librustc_metadata/decoder.rs
@@ -553,16 +553,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| {
-        let mut decoder = reader::Decoder::new(doc);
-        Decodable::decode(&mut decoder).unwrap()
+        Decodable::decode(&mut doc.opaque()).unwrap()
     })
 }
 
 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| {
-        let mut decoder = reader::Decoder::new(doc);
-        Decodable::decode(&mut decoder).unwrap()
+        Decodable::decode(&mut doc.opaque()).unwrap()
     })
 }
 
@@ -579,19 +577,12 @@ 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);
-    match reader::maybe_get_doc(item, tag_items_data_item_repr).map(|doc| {
-        let mut decoder = reader::Decoder::new(doc);
-        Decodable::decode(&mut decoder).unwrap()
-    }) {
-        Some(attrs) => attrs,
-        None => Vec::new(),
-    }
+    reader::maybe_get_doc(item, tag_items_data_item_repr).map_or(vec![], |doc| {
+        Decodable::decode(&mut doc.opaque()).unwrap()
+    })
 }
 
-pub fn get_impl_polarity<'tcx>(cdata: Cmd,
-                               id: DefIndex)
-                               -> Option<hir::ImplPolarity>
-{
+pub fn get_impl_polarity(cdata: Cmd, id: DefIndex) -> Option<hir::ImplPolarity> {
     let item_doc = cdata.lookup_item(id);
     let fam = item_family(item_doc);
     match fam {
@@ -602,15 +593,14 @@ pub fn get_impl_polarity<'tcx>(cdata: Cmd,
     }
 }
 
-pub fn get_custom_coerce_unsized_kind<'tcx>(
+pub fn get_custom_coerce_unsized_kind(
     cdata: Cmd,
     id: DefIndex)
     -> 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| {
-        let mut decoder = reader::Decoder::new(kind_doc);
-        Decodable::decode(&mut decoder).unwrap()
+        Decodable::decode(&mut kind_doc.opaque()).unwrap()
     })
 }
 
@@ -989,8 +979,7 @@ pub fn get_trait_item_def_ids(cdata: Cmd, id: DefIndex)
 pub fn get_item_variances(cdata: Cmd, id: DefIndex) -> Vec<ty::Variance> {
     let item_doc = cdata.lookup_item(id);
     let variance_doc = reader::get_doc(item_doc, tag_item_variances);
-    let mut decoder = reader::Decoder::new(variance_doc);
-    Decodable::decode(&mut decoder).unwrap()
+    Decodable::decode(&mut variance_doc.opaque()).unwrap()
 }
 
 pub fn get_provided_trait_methods<'a, 'tcx>(cdata: Cmd,
@@ -1109,10 +1098,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| {
-        let mut decoder = reader::Decoder::new(attrs_doc);
-        let mut attrs: Vec<ast::Attribute> = decoder.read_opaque(|opaque_decoder, _| {
-            Decodable::decode(opaque_decoder)
-        }).unwrap();
+        let mut attrs = Vec::<ast::Attribute>::decode(&mut attrs_doc.opaque()).unwrap();
 
         // Need new unique IDs: old thread-local IDs won't map to new threads.
         for attr in attrs.iter_mut() {
@@ -1575,18 +1561,14 @@ pub fn get_imported_filemaps(metadata: &[u8]) -> Vec<syntax_pos::FileMap> {
     let cm_doc = reader::get_doc(crate_doc, tag_codemap);
 
     reader::tagged_docs(cm_doc, tag_codemap_filemap).map(|filemap_doc| {
-        let mut decoder = reader::Decoder::new(filemap_doc);
-        decoder.read_opaque(|opaque_decoder, _| {
-            Decodable::decode(opaque_decoder)
-        }).unwrap()
+        Decodable::decode(&mut filemap_doc.opaque()).unwrap()
     }).collect()
 }
 
 pub fn closure_kind(cdata: Cmd, closure_id: DefIndex) -> ty::ClosureKind {
     let closure_doc = cdata.lookup_item(closure_id);
     let closure_kind_doc = reader::get_doc(closure_doc, tag_items_closure_kind);
-    let mut decoder = reader::Decoder::new(closure_kind_doc);
-    ty::ClosureKind::decode(&mut decoder).unwrap()
+    ty::ClosureKind::decode(&mut closure_kind_doc.opaque()).unwrap()
 }
 
 pub fn closure_ty<'a, 'tcx>(cdata: Cmd, closure_id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>)
@@ -1606,8 +1588,7 @@ 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 mut decoder = reader::Decoder::new(def_key_doc);
-            let simple_key = def_key::DefKey::decode(&mut decoder).unwrap();
+            let simple_key = def_key::DefKey::decode(&mut def_key_doc.opaque()).unwrap();
             let name = reader::maybe_get_doc(item_doc, tag_paths_data_name).map(|name| {
                 token::intern(name.as_str()).as_str()
             });
diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
index 3b6984a8c46..3197d52e14d 100644
--- a/src/librustc_metadata/encoder.rs
+++ b/src/librustc_metadata/encoder.rs
@@ -132,7 +132,7 @@ fn encode_def_id(ecx: &mut EncodeContext, id: DefId) {
 fn encode_def_key(ecx: &mut EncodeContext, key: DefKey) {
     let simple_key = def_key::simplify_def_key(key);
     ecx.start_tag(tag_def_key);
-    simple_key.encode(ecx);
+    simple_key.encode(&mut ecx.opaque());
     ecx.end_tag();
 }
 
@@ -171,7 +171,7 @@ pub fn def_to_string(_tcx: TyCtxt, did: DefId) -> String {
 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);
-    v.encode(ecx);
+    v.encode(&mut ecx.opaque());
     ecx.end_tag();
 }
 
@@ -786,7 +786,7 @@ impl<'a, 'b, 'tcx> ItemContentBuilder<'a, 'b, 'tcx> {
                                                     attr));
         }
         self.start_tag(tag_items_data_item_repr);
-        repr_attrs.encode(self.ecx);
+        repr_attrs.encode(&mut self.opaque());
         self.end_tag();
     }
 
@@ -821,7 +821,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);
-        stab.encode(ecx).unwrap();
+        stab.encode(&mut ecx.opaque()).unwrap();
         ecx.end_tag();
     });
 }
@@ -829,7 +829,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);
-        depr.encode(ecx).unwrap();
+        depr.encode(&mut ecx.opaque()).unwrap();
         ecx.end_tag();
     });
 }
@@ -1068,7 +1068,7 @@ impl<'a, 'b, 'tcx> ItemContentBuilder<'a, 'b, 'tcx> {
                 {
                     Some(&kind) => {
                         self.start_tag(tag_impl_coerce_unsized_kind);
-                        kind.encode(self.ecx);
+                        kind.encode(&mut self.opaque());
                         self.end_tag();
                     }
                     None => {}
@@ -1386,7 +1386,7 @@ impl<'a, 'b, 'tcx> ItemContentBuilder<'a, 'b, 'tcx> {
         self.end_tag();
 
         self.start_tag(tag_items_closure_kind);
-        tcx.closure_kind(def_id).encode(self.ecx).unwrap();
+        tcx.closure_kind(def_id).encode(&mut self.opaque()).unwrap();
         self.end_tag();
 
         assert!(self.mir_map.map.contains_key(&def_id));
@@ -1428,9 +1428,7 @@ fn encode_item_index(ecx: &mut EncodeContext, index: IndexData) {
 
 fn encode_attributes(ecx: &mut EncodeContext, attrs: &[ast::Attribute]) {
     ecx.start_tag(tag_attributes);
-    ecx.emit_opaque(|opaque_encoder| {
-        attrs.encode(opaque_encoder)
-    }).unwrap();
+    attrs.encode(&mut ecx.opaque()).unwrap();
     ecx.end_tag();
 }
 
@@ -1565,9 +1563,7 @@ fn encode_codemap(ecx: &mut EncodeContext) {
         }
 
         ecx.start_tag(tag_codemap_filemap);
-        ecx.emit_opaque(|opaque_encoder| {
-            filemap.encode(opaque_encoder)
-        }).unwrap();
+        filemap.encode(&mut ecx.opaque()).unwrap();
         ecx.end_tag();
     }
 
diff --git a/src/librustc_metadata/rbml/reader.rs b/src/librustc_metadata/rbml/reader.rs
index d4ac97ce5e0..7878d8af989 100644
--- a/src/librustc_metadata/rbml/reader.rs
+++ b/src/librustc_metadata/rbml/reader.rs
@@ -158,6 +158,10 @@ impl<'doc> Doc<'doc> {
     pub fn to_string(&self) -> String {
         self.as_str().to_string()
     }
+
+    pub fn opaque(&self) -> opaque::Decoder<'doc> {
+        opaque::Decoder::new(self.data, self.start)
+    }
 }
 
 pub struct TaggedDoc<'a> {
@@ -670,12 +674,7 @@ impl<'doc> Decoder<'doc> {
         where F: FnOnce(&mut opaque::Decoder, Doc) -> DecodeResult<R>
     {
         let doc = self.next_doc(EsOpaque)?;
-
-        let result = {
-            let mut opaque_decoder = opaque::Decoder::new(doc.data, doc.start);
-            op(&mut opaque_decoder, doc)?
-        };
-
+        let result = op(&mut doc.opaque(), doc)?;
         Ok(result)
     }
 
diff --git a/src/librustc_metadata/rbml/writer.rs b/src/librustc_metadata/rbml/writer.rs
index b49686e2379..db3a51187c6 100644
--- a/src/librustc_metadata/rbml/writer.rs
+++ b/src/librustc_metadata/rbml/writer.rs
@@ -241,9 +241,7 @@ impl Encoder {
         }
         pos
     }
-}
 
-impl Encoder {
     // used internally to emit things like the vector length and so on
     fn _emit_tagged_sub(&mut self, v: usize) -> EncodeResult {
         if v as u8 as usize == v {
@@ -256,16 +254,15 @@ impl Encoder {
         }
     }
 
+    pub fn opaque(&mut self) -> opaque::Encoder {
+        opaque::Encoder::new(&mut self.writer)
+    }
+
     pub fn emit_opaque<F>(&mut self, f: F) -> EncodeResult
         where F: FnOnce(&mut opaque::Encoder) -> EncodeResult
     {
         self.start_tag(EsOpaque as usize)?;
-
-        {
-            let mut opaque_encoder = opaque::Encoder::new(&mut self.writer);
-            f(&mut opaque_encoder)?;
-        }
-
+        f(&mut self.opaque())?;
         self.mark_stable_position();
         self.end_tag()
     }