rustc_metadata: replace Lazy<[Table<T>]> with Lazy<Table<T>>.

Author: eddyb

src/librustc_metadata/decoder.rs

@@ -2,6 +2,7 @@
 
 use crate::cstore::{self, CrateMetadata, MetadataBlob, NativeLibrary, ForeignModule};
 use crate::schema::*;
+use crate::table::Table;
 
 use rustc_data_structures::sync::{Lrc, ReadGuard};
 use rustc::hir::map::{DefKey, DefPath, DefPathData, DefPathHash, Definitions};
@@ -27,7 +28,7 @@ use std::mem;
 use std::num::NonZeroUsize;
 use std::u32;
 
-use rustc_serialize::{Decodable, Decoder, SpecializedDecoder, opaque};
+use rustc_serialize::{Decodable, Decoder, Encodable, SpecializedDecoder, opaque};
 use syntax::attr;
 use syntax::ast::{self, Ident};
 use syntax::source_map;
@@ -128,15 +129,15 @@ impl<'a, 'tcx> Metadata<'a, 'tcx> for (&'a CrateMetadata, TyCtxt<'a, 'tcx, 'tcx>
     }
 }
 
-impl<'a, 'tcx: 'a, T: Decodable> Lazy<T> {
+impl<'a, 'tcx: 'a, T: Encodable + Decodable> Lazy<T> {
     pub fn decode<M: Metadata<'a, 'tcx>>(self, meta: M) -> T {
         let mut dcx = meta.decoder(self.position.get());
         dcx.lazy_state = LazyState::NodeStart(self.position);
         T::decode(&mut dcx).unwrap()
     }
 }
 
-impl<'a, 'tcx: 'a, T: Decodable> Lazy<[T]> {
+impl<'a, 'tcx: 'a, T: Encodable + Decodable> Lazy<[T]> {
     pub fn decode<M: Metadata<'a, 'tcx>>(
         self,
         meta: M,
@@ -236,13 +237,13 @@ impl<'a, 'tcx: 'a> TyDecoder<'a, 'tcx> for DecodeContext<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx, T> SpecializedDecoder<Lazy<T>> for DecodeContext<'a, 'tcx> {
+impl<'a, 'tcx, T: Encodable> SpecializedDecoder<Lazy<T>> for DecodeContext<'a, 'tcx> {
     fn specialized_decode(&mut self) -> Result<Lazy<T>, Self::Error> {
         self.read_lazy_with_meta(())
     }
 }
 
-impl<'a, 'tcx, T> SpecializedDecoder<Lazy<[T]>> for DecodeContext<'a, 'tcx> {
+impl<'a, 'tcx, T: Encodable> SpecializedDecoder<Lazy<[T]>> for DecodeContext<'a, 'tcx> {
     fn specialized_decode(&mut self) -> Result<Lazy<[T]>, Self::Error> {
         let len = self.read_usize()?;
         if len == 0 {
@@ -253,6 +254,14 @@ impl<'a, 'tcx, T> SpecializedDecoder<Lazy<[T]>> for DecodeContext<'a, 'tcx> {
     }
 }
 
+impl<'a, 'tcx, T> SpecializedDecoder<Lazy<Table<T>>> for DecodeContext<'a, 'tcx>
+    where T: LazyMeta<Meta = ()>,
+{
+    fn specialized_decode(&mut self) -> Result<Lazy<Table<T>>, Self::Error> {
+        let len = self.read_usize()?;
+        self.read_lazy_with_meta(len)
+    }
+}
 
 impl<'a, 'tcx> SpecializedDecoder<DefId> for DecodeContext<'a, 'tcx> {
     #[inline]

src/librustc_metadata/encoder.rs

@@ -96,13 +96,13 @@ impl<'a, 'tcx> Encoder for EncodeContext<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx, T> SpecializedEncoder<Lazy<T>> for EncodeContext<'a, 'tcx> {
+impl<'a, 'tcx, T: Encodable> SpecializedEncoder<Lazy<T>> for EncodeContext<'a, 'tcx> {
     fn specialized_encode(&mut self, lazy: &Lazy<T>) -> Result<(), Self::Error> {
         self.emit_lazy_distance(*lazy)
     }
 }
 
-impl<'a, 'tcx, T> SpecializedEncoder<Lazy<[T]>> for EncodeContext<'a, 'tcx> {
+impl<'a, 'tcx, T: Encodable> SpecializedEncoder<Lazy<[T]>> for EncodeContext<'a, 'tcx> {
     fn specialized_encode(&mut self, lazy: &Lazy<[T]>) -> Result<(), Self::Error> {
         self.emit_usize(lazy.meta)?;
         if lazy.meta == 0 {
@@ -112,6 +112,15 @@ impl<'a, 'tcx, T> SpecializedEncoder<Lazy<[T]>> for EncodeContext<'a, 'tcx> {
     }
 }
 
+impl<'a, 'tcx, T> SpecializedEncoder<Lazy<Table<T>>> for EncodeContext<'a, 'tcx>
+    where T: LazyMeta<Meta = ()>,
+{
+    fn specialized_encode(&mut self, lazy: &Lazy<Table<T>>) -> Result<(), Self::Error> {
+        self.emit_usize(lazy.meta)?;
+        self.emit_lazy_distance(*lazy)
+    }
+}
+
 impl<'a, 'tcx> SpecializedEncoder<CrateNum> for EncodeContext<'a, 'tcx> {
     #[inline]
     fn specialized_encode(&mut self, cnum: &CrateNum) -> Result<(), Self::Error> {
@@ -250,7 +259,7 @@ impl<T: Encodable> EncodeContentsForLazy<T> for T {
     }
 }
 
-impl<I, T> EncodeContentsForLazy<[T]> for I
+impl<I, T: Encodable> EncodeContentsForLazy<[T]> for I
     where I: IntoIterator,
           I::Item: EncodeContentsForLazy<T>,
 {

src/librustc_metadata/schema.rs

@@ -12,7 +12,7 @@ use rustc::ty::{self, Ty, ReprOptions};
 use rustc_target::spec::{PanicStrategy, TargetTriple};
 use rustc_data_structures::svh::Svh;
 
-use rustc_serialize as serialize;
+use rustc_serialize::{self as serialize, Encodable};
 use syntax::{ast, attr};
 use syntax::edition::Edition;
 use syntax::symbol::Symbol;
@@ -52,7 +52,7 @@ pub trait LazyMeta {
     fn min_size(meta: Self::Meta) -> usize;
 }
 
-impl<T> LazyMeta for T {
+impl<T: Encodable> LazyMeta for T {
     type Meta = ();
 
     fn min_size(_: ()) -> usize {
@@ -61,7 +61,7 @@ impl<T> LazyMeta for T {
     }
 }
 
-impl<T> LazyMeta for [T] {
+impl<T: Encodable> LazyMeta for [T] {
     type Meta = usize;
 
     fn min_size(len: usize) -> usize {
@@ -117,13 +117,13 @@ impl<T: ?Sized + LazyMeta> Lazy<T> {
     }
 }
 
-impl<T> Lazy<T> {
+impl<T: Encodable> Lazy<T> {
     pub fn from_position(position: NonZeroUsize) -> Lazy<T> {
         Lazy::from_position_and_meta(position, ())
     }
 }
 
-impl<T> Lazy<[T]> {
+impl<T: Encodable> Lazy<[T]> {
     pub fn empty() -> Lazy<[T]> {
         Lazy::from_position_and_meta(NonZeroUsize::new(1).unwrap(), 0)
     }
@@ -159,6 +159,7 @@ pub enum LazyState {
 // manually, instead of relying on the default, to get the correct variance.
 // Only needed when `T` itself contains a parameter (e.g. `'tcx`).
 macro_rules! Lazy {
+    (Table<$T:ty>) => {Lazy<Table<$T>, usize>};
     ([$T:ty]) => {Lazy<[$T], usize>};
     ($T:ty) => {Lazy<$T, ()>};
 }
@@ -192,7 +193,7 @@ pub struct CrateRoot<'tcx> {
     pub exported_symbols: Lazy!([(ExportedSymbol<'tcx>, SymbolExportLevel)]),
     pub interpret_alloc_index: Lazy<[u32]>,
 
-    pub entries_table: Lazy!([Table<Entry<'tcx>>]),
+    pub entries_table: Lazy!(Table<Entry<'tcx>>),
 
     pub compiler_builtins: bool,
     pub needs_allocator: bool,

src/librustc_metadata/table.rs

@@ -1,7 +1,7 @@
 use crate::schema::*;
 
 use rustc::hir::def_id::{DefId, DefIndex, DefIndexAddressSpace};
-use rustc_serialize::opaque::Encoder;
+use rustc_serialize::{Encodable, opaque::Encoder};
 use std::marker::PhantomData;
 use std::num::NonZeroUsize;
 use log::debug;
@@ -10,12 +10,12 @@ use log::debug;
 /// (e.g. while visiting the definitions of a crate), and on-demand decoding
 /// of specific indices (e.g. queries for per-definition data).
 /// Similar to `Vec<Lazy<T>>`, but with zero-copy decoding.
-pub struct Table<T> {
+pub struct Table<T: LazyMeta<Meta = ()>> {
     positions: [Vec<u8>; 2],
     _marker: PhantomData<T>,
 }
 
-impl<T> Table<T> {
+impl<T: LazyMeta<Meta = ()>> Table<T> {
     pub fn new((max_index_lo, max_index_hi): (usize, usize)) -> Self {
         Table {
             positions: [vec![0; max_index_lo * 4],
@@ -45,7 +45,7 @@ impl<T> Table<T> {
         write_le_u32(destination, position);
     }
 
-    pub fn encode(&self, buf: &mut Encoder) -> Lazy<[Self]> {
+    pub fn encode(&self, buf: &mut Encoder) -> Lazy<Self> {
         let pos = buf.position();
 
         // First we write the length of the lower range ...
@@ -61,7 +61,15 @@ impl<T> Table<T> {
     }
 }
 
-impl<T> Lazy<[Table<T>]> {
+impl<T: LazyMeta<Meta = ()>> LazyMeta for Table<T> {
+    type Meta = usize;
+
+    fn min_size(len: usize) -> usize {
+        len * 4
+    }
+}
+
+impl<T: Encodable> Lazy<Table<T>> {
     /// Given the metadata, extract out the offset of a particular
     /// DefIndex (if any).
     #[inline(never)]