rustc_metadata: parametrize Table by element type.

Author: eddyb

src/librustc_metadata/encoder.rs

@@ -45,7 +45,7 @@ pub struct EncodeContext<'a, 'tcx: 'a> {
     opaque: opaque::Encoder,
     pub tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
-    entries_table: Table<'tcx>,
+    entries_table: Table<Entry<'tcx>>,
 
     lazy_state: LazyState,
     type_shorthands: FxHashMap<Ty<'tcx>, usize>,

src/librustc_metadata/schema.rs

@@ -155,6 +155,14 @@ pub enum LazyState {
     Previous(NonZeroUsize),
 }
 
+// FIXME(#59875) `Lazy!(T)` replaces `Lazy<T>`, passing the `Meta` parameter
+// 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 {
+    ([$T:ty]) => {Lazy<[$T], usize>};
+    ($T:ty) => {Lazy<$T, ()>};
+}
+
 #[derive(RustcEncodable, RustcDecodable)]
 pub struct CrateRoot<'tcx> {
     pub name: Symbol,
@@ -181,10 +189,10 @@ pub struct CrateRoot<'tcx> {
     pub source_map: Lazy<[syntax_pos::SourceFile]>,
     pub def_path_table: Lazy<hir::map::definitions::DefPathTable>,
     pub impls: Lazy<[TraitImpls]>,
-    pub exported_symbols: Lazy<[(ExportedSymbol<'tcx>, SymbolExportLevel)]>,
+    pub exported_symbols: Lazy!([(ExportedSymbol<'tcx>, SymbolExportLevel)]),
     pub interpret_alloc_index: Lazy<[u32]>,
 
-    pub entries_table: Lazy<[Table<'tcx>]>,
+    pub entries_table: Lazy!([Table<Entry<'tcx>>]),
 
     pub compiler_builtins: bool,
     pub needs_allocator: bool,
@@ -219,14 +227,14 @@ pub struct Entry<'tcx> {
     pub stability: Option<Lazy<attr::Stability>>,
     pub deprecation: Option<Lazy<attr::Deprecation>>,
 
-    pub ty: Option<Lazy<Ty<'tcx>>>,
+    pub ty: Option<Lazy!(Ty<'tcx>)>,
     pub inherent_impls: Lazy<[DefIndex]>,
     pub variances: Lazy<[ty::Variance]>,
     pub generics: Option<Lazy<ty::Generics>>,
-    pub predicates: Option<Lazy<ty::GenericPredicates<'tcx>>>,
-    pub predicates_defined_on: Option<Lazy<ty::GenericPredicates<'tcx>>>,
+    pub predicates: Option<Lazy!(ty::GenericPredicates<'tcx>)>,
+    pub predicates_defined_on: Option<Lazy!(ty::GenericPredicates<'tcx>)>,
 
-    pub mir: Option<Lazy<mir::Mir<'tcx>>>,
+    pub mir: Option<Lazy!(mir::Mir<'tcx>)>,
 }
 
 #[derive(Copy, Clone, RustcEncodable, RustcDecodable)]
@@ -245,22 +253,22 @@ pub enum EntryKind<'tcx> {
     Existential,
     Enum(ReprOptions),
     Field,
-    Variant(Lazy<VariantData<'tcx>>),
-    Struct(Lazy<VariantData<'tcx>>, ReprOptions),
-    Union(Lazy<VariantData<'tcx>>, ReprOptions),
-    Fn(Lazy<FnData<'tcx>>),
-    ForeignFn(Lazy<FnData<'tcx>>),
+    Variant(Lazy!(VariantData<'tcx>)),
+    Struct(Lazy!(VariantData<'tcx>), ReprOptions),
+    Union(Lazy!(VariantData<'tcx>), ReprOptions),
+    Fn(Lazy!(FnData<'tcx>)),
+    ForeignFn(Lazy!(FnData<'tcx>)),
     Mod(Lazy<ModData>),
     MacroDef(Lazy<MacroDef>),
-    Closure(Lazy<ClosureData<'tcx>>),
-    Generator(Lazy<GeneratorData<'tcx>>),
-    Trait(Lazy<TraitData<'tcx>>),
-    Impl(Lazy<ImplData<'tcx>>),
-    Method(Lazy<MethodData<'tcx>>),
+    Closure(Lazy!(ClosureData<'tcx>)),
+    Generator(Lazy!(GeneratorData<'tcx>)),
+    Trait(Lazy!(TraitData<'tcx>)),
+    Impl(Lazy!(ImplData<'tcx>)),
+    Method(Lazy!(MethodData<'tcx>)),
     AssociatedType(AssociatedContainer),
     AssociatedExistential(AssociatedContainer),
     AssociatedConst(AssociatedContainer, ConstQualif, Lazy<RenderedConst>),
-    TraitAlias(Lazy<TraitAliasData<'tcx>>),
+    TraitAlias(Lazy!(TraitAliasData<'tcx>)),
 }
 
 /// Additional data for EntryKind::Const and EntryKind::AssociatedConst
@@ -290,7 +298,7 @@ pub struct MacroDef {
 pub struct FnData<'tcx> {
     pub constness: hir::Constness,
     pub arg_names: Lazy<[ast::Name]>,
-    pub sig: Lazy<ty::PolyFnSig<'tcx>>,
+    pub sig: Lazy!(ty::PolyFnSig<'tcx>),
 }
 
 #[derive(RustcEncodable, RustcDecodable)]
@@ -301,7 +309,7 @@ pub struct VariantData<'tcx> {
     pub ctor: Option<DefIndex>,
     /// If this is a tuple struct or variant
     /// ctor, this is its "function" signature.
-    pub ctor_sig: Option<Lazy<ty::PolyFnSig<'tcx>>>,
+    pub ctor_sig: Option<Lazy!(ty::PolyFnSig<'tcx>)>,
 }
 
 #[derive(RustcEncodable, RustcDecodable)]
@@ -310,12 +318,12 @@ pub struct TraitData<'tcx> {
     pub paren_sugar: bool,
     pub has_auto_impl: bool,
     pub is_marker: bool,
-    pub super_predicates: Lazy<ty::GenericPredicates<'tcx>>,
+    pub super_predicates: Lazy!(ty::GenericPredicates<'tcx>),
 }
 
 #[derive(RustcEncodable, RustcDecodable)]
 pub struct TraitAliasData<'tcx> {
-    pub super_predicates: Lazy<ty::GenericPredicates<'tcx>>,
+    pub super_predicates: Lazy!(ty::GenericPredicates<'tcx>),
 }
 
 #[derive(RustcEncodable, RustcDecodable)]
@@ -326,7 +334,7 @@ pub struct ImplData<'tcx> {
 
     /// This is `Some` only for impls of `CoerceUnsized`.
     pub coerce_unsized_info: Option<ty::adjustment::CoerceUnsizedInfo>,
-    pub trait_ref: Option<Lazy<ty::TraitRef<'tcx>>>,
+    pub trait_ref: Option<Lazy!(ty::TraitRef<'tcx>)>,
 }
 
 
@@ -377,7 +385,7 @@ pub struct MethodData<'tcx> {
 
 #[derive(RustcEncodable, RustcDecodable)]
 pub struct ClosureData<'tcx> {
-    pub sig: Lazy<ty::PolyFnSig<'tcx>>,
+    pub sig: Lazy!(ty::PolyFnSig<'tcx>),
 }
 
 #[derive(RustcEncodable, RustcDecodable)]

src/librustc_metadata/table.rs

@@ -6,19 +6,16 @@ use std::marker::PhantomData;
 use std::num::NonZeroUsize;
 use log::debug;
 
-/// While we are generating the metadata, we also track the position
-/// of each DefIndex. It is not required that all definitions appear
-/// in the metadata, nor that they are serialized in order, and
-/// therefore we first allocate the vector here and fill it with
-/// `0`. Whenever an index is visited, we fill in the
-/// appropriate spot by calling `record_position`. We should never
-/// visit the same index twice.
-pub struct Table<'tcx> {
+/// Random-access position table, allowing encoding in an arbitrary order
+/// (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> {
     positions: [Vec<u8>; 2],
-    _marker: PhantomData<&'tcx ()>,
+    _marker: PhantomData<T>,
 }
 
-impl Table<'tcx> {
+impl<T> Table<T> {
     pub fn new((max_index_lo, max_index_hi): (usize, usize)) -> Self {
         Table {
             positions: [vec![0; max_index_lo * 4],
@@ -27,12 +24,12 @@ impl Table<'tcx> {
         }
     }
 
-    pub fn record(&mut self, def_id: DefId, entry: Lazy<Entry<'tcx>>) {
+    pub fn record(&mut self, def_id: DefId, entry: Lazy<T>) {
         assert!(def_id.is_local());
         self.record_index(def_id.index, entry);
     }
 
-    pub fn record_index(&mut self, item: DefIndex, entry: Lazy<Entry<'tcx>>) {
+    pub fn record_index(&mut self, item: DefIndex, entry: Lazy<T>) {
         let position = entry.position.get() as u32;
         assert_eq!(position as usize, entry.position.get());
         let space_index = item.address_space().index();
@@ -64,11 +61,11 @@ impl Table<'tcx> {
     }
 }
 
-impl Lazy<[Table<'tcx>]> {
+impl<T> Lazy<[Table<T>]> {
     /// Given the metadata, extract out the offset of a particular
     /// DefIndex (if any).
     #[inline(never)]
-    pub fn lookup(&self, bytes: &[u8], def_index: DefIndex) -> Option<Lazy<Entry<'tcx>>> {
+    pub fn lookup(&self, bytes: &[u8], def_index: DefIndex) -> Option<Lazy<T>> {
         debug!("Table::lookup: index={:?} len={:?}",
                def_index,
                self.meta);