temp

Author: jdonszelmann

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -29,7 +29,6 @@ use rustc_middle::{bug, implement_ty_decoder};
 use rustc_proc_macro::bridge::client::ProcMacro;
 use rustc_serialize::opaque::MemDecoder;
 use rustc_serialize::{Decodable, Decoder};
-use rustc_session::Session;
 use rustc_session::config::TargetModifier;
 use rustc_session::cstore::{CrateSource, ExternCrate};
 use rustc_span::hygiene::HygieneDecodeContext;
@@ -215,8 +214,7 @@ impl<'a> LazyDecoder for BlobDecodeContext<'a> {
 pub(super) struct MetadataDecodeContext<'a, 'tcx> {
     blob_decoder: BlobDecodeContext<'a>,
     cdata: CrateMetadataRef<'a>,
-    sess: Option<&'tcx Session>,
-    tcx: Option<TyCtxt<'tcx>>,
+    tcx: TyCtxt<'tcx>,
 
     // Used for decoding interpret::AllocIds in a cached & thread-safe manner.
     alloc_decoding_session: AllocDecodingSession<'a>,
@@ -246,25 +244,14 @@ impl<'a, 'tcx> Deref for MetadataDecodeContext<'a, 'tcx> {
     }
 }
 
-pub(super) trait BlobMetadata<'a>: Copy {
+pub(super) trait Metadata<'a>: Copy {
     type Context: BlobDecoder + LazyDecoder;
 
     fn blob(self) -> &'a MetadataBlob;
     fn decoder(self, pos: usize) -> Self::Context;
 }
 
-/// Abstract over the various ways one can create metadata decoders.
-pub(super) trait Metadata<'a, 'tcx>: Copy {
-    fn cdata(self) -> CrateMetadataRef<'a>;
-    fn sess(self) -> Option<&'tcx Session> {
-        None
-    }
-    fn tcx(self) -> Option<TyCtxt<'tcx>> {
-        None
-    }
-}
-
-impl<'a> BlobMetadata<'a> for &'a MetadataBlob {
+impl<'a> Metadata<'a> for &'a MetadataBlob {
     type Context = BlobDecodeContext<'a>;
 
     fn blob(self) -> &'a MetadataBlob {
@@ -287,40 +274,26 @@ impl<'a> BlobMetadata<'a> for &'a MetadataBlob {
     }
 }
 
-impl<'a, 'tcx> BlobMetadata<'a> for (CrateMetadataRef<'a>, TyCtxt<'tcx>) {
+impl<'a, 'tcx> Metadata<'a> for (CrateMetadataRef<'a>, TyCtxt<'tcx>) {
     type Context = MetadataDecodeContext<'a, 'tcx>;
 
     fn blob(self) -> &'a MetadataBlob {
         &self.0.cdata.blob
     }
 
     fn decoder(self, pos: usize) -> MetadataDecodeContext<'a, 'tcx> {
-        let tcx = self.tcx();
-        let cdata = self.cdata();
         MetadataDecodeContext {
             blob_decoder: self.blob().decoder(pos),
-            cdata,
-            sess: self.sess().or(tcx.map(|tcx| tcx.sess)),
-            tcx,
-            alloc_decoding_session: cdata.cdata.alloc_decoding_state.new_decoding_session(),
+            cdata: self.0,
+            tcx: self.1,
+            alloc_decoding_session: self.0.cdata.alloc_decoding_state.new_decoding_session(),
         }
     }
 }
 
-impl<'a, 'tcx> Metadata<'a, 'tcx> for (CrateMetadataRef<'a>, TyCtxt<'tcx>) {
-    #[inline]
-    fn cdata(self) -> CrateMetadataRef<'a> {
-        self.0
-    }
-    #[inline]
-    fn tcx(self) -> Option<TyCtxt<'tcx>> {
-        Some(self.1)
-    }
-}
-
 impl<T: ParameterizedOverTcx> LazyValue<T> {
     #[inline]
-    fn decode<'a, 'tcx, M: BlobMetadata<'a>>(self, metadata: M) -> T::Value<'tcx>
+    fn decode<'a, 'tcx, M: Metadata<'a>>(self, metadata: M) -> T::Value<'tcx>
     where
         T::Value<'tcx>: Decodable<M::Context>,
     {
@@ -360,7 +333,7 @@ unsafe impl<D: Decoder, T: Decodable<D>> TrustedLen for DecodeIterator<T, D> {}
 
 impl<T: ParameterizedOverTcx> LazyArray<T> {
     #[inline]
-    fn decode<'a, 'tcx, M: BlobMetadata<'a>>(
+    fn decode<'a, 'tcx, M: Metadata<'a>>(
         self,
         metadata: M,
     ) -> DecodeIterator<T::Value<'tcx>, M::Context>
@@ -374,17 +347,6 @@ impl<T: ParameterizedOverTcx> LazyArray<T> {
 }
 
 impl<'a, 'tcx> MetadataDecodeContext<'a, 'tcx> {
-    #[inline]
-    fn tcx(&self) -> TyCtxt<'tcx> {
-        let Some(tcx) = self.tcx else {
-            bug!(
-                "No TyCtxt found for decoding. \
-                You need to explicitly pass `(crate_metadata_ref, tcx)` to `decode` instead of just `crate_metadata_ref`."
-            );
-        };
-        tcx
-    }
-
     #[inline]
     fn map_encoded_cnum_to_current(&self, cnum: CrateNum) -> CrateNum {
         self.cdata.map_encoded_cnum_to_current(cnum)
@@ -425,14 +387,14 @@ impl<'a, 'tcx> TyDecoder<'tcx> for MetadataDecodeContext<'a, 'tcx> {
 
     #[inline]
     fn interner(&self) -> TyCtxt<'tcx> {
-        self.tcx()
+        self.tcx
     }
 
     fn cached_ty_for_shorthand<F>(&mut self, shorthand: usize, or_insert_with: F) -> Ty<'tcx>
     where
         F: FnOnce(&mut Self) -> Ty<'tcx>,
     {
-        let tcx = self.tcx();
+        let tcx = self.tcx;
 
         let key = ty::CReaderCacheKey { cnum: Some(self.cdata.cnum), pos: shorthand };
 
@@ -473,8 +435,7 @@ impl<'a, 'tcx> Decodable<MetadataDecodeContext<'a, 'tcx>> for ExpnIndex {
 
 impl<'a, 'tcx> SpanDecoder for MetadataDecodeContext<'a, 'tcx> {
     fn decode_attr_id(&mut self) -> rustc_span::AttrId {
-        let sess = self.sess.expect("can't decode AttrId without Session");
-        sess.psess.attr_id_generator.mk_attr_id()
+        self.tcx.sess.psess.attr_id_generator.mk_attr_id()
     }
 
     fn decode_crate_num(&mut self) -> CrateNum {
@@ -488,12 +449,7 @@ impl<'a, 'tcx> SpanDecoder for MetadataDecodeContext<'a, 'tcx> {
 
     fn decode_syntax_context(&mut self) -> SyntaxContext {
         let cdata = self.cdata;
-        let Some(tcx) = self.tcx else {
-            bug!(
-                "Cannot decode SyntaxContext without Session.\
-                You need to explicitly pass `(crate_metadata_ref, tcx)` to `decode` instead of just `crate_metadata_ref`."
-            );
-        };
+        let tcx = self.tcx;
 
         let cname = cdata.root.name();
         rustc_span::hygiene::decode_syntax_context(self, &cdata.hygiene_context, |_, id| {
@@ -510,13 +466,7 @@ impl<'a, 'tcx> SpanDecoder for MetadataDecodeContext<'a, 'tcx> {
     fn decode_expn_id(&mut self) -> ExpnId {
         let local_cdata = self.cdata;
 
-        let Some(tcx) = self.tcx else {
-            bug!(
-                "Cannot decode ExpnId without Session. \
-                You need to explicitly pass `(crate_metadata_ref, tcx)` to `decode` instead of just `crate_metadata_ref`."
-            );
-        };
-
+        let tcx = self.tcx;
         let cnum = CrateNum::decode(self);
         let index = u32::decode(self);
 
@@ -620,12 +570,7 @@ impl<'a, 'tcx> Decodable<MetadataDecodeContext<'a, 'tcx>> for SpanData {
         let len = tag.length().unwrap_or_else(|| BytePos::decode(decoder));
         let hi = lo + len;
 
-        let Some(tcx) = decoder.tcx else {
-            bug!(
-                "Cannot decode Span without Session. \
-                You need to explicitly pass `(crate_metadata_ref, tcx)` to `decode` instead of just `crate_metadata_ref`."
-            )
-        };
+        let tcx = decoder.tcx;
 
         // Index of the file in the corresponding crate's list of encoded files.
         let metadata_index = u32::decode(decoder);

compiler/rustc_metadata/src/rmeta/table.rs

@@ -1,7 +1,7 @@
 use rustc_hir::def::CtorOf;
 use rustc_index::Idx;
 
-use crate::rmeta::decoder::BlobMetadata;
+use crate::rmeta::decoder::Metadata;
 use crate::rmeta::*;
 
 pub(super) trait IsDefault: Default {
@@ -548,7 +548,7 @@ where
     for<'tcx> T::Value<'tcx>: FixedSizeEncoding<ByteArray = [u8; N]>,
 {
     /// Given the metadata, extract out the value at a particular index (if any).
-    pub(super) fn get<'a, 'tcx, M: BlobMetadata<'a>>(&self, metadata: M, i: I) -> T::Value<'tcx> {
+    pub(super) fn get<'a, 'tcx, M: Metadata<'a>>(&self, metadata: M, i: I) -> T::Value<'tcx> {
         // Access past the end of the table returns a Default
         if i.index() >= self.len {
             return Default::default();