refactor: remove the tcx field in Tables

the only functionality of `Tables` is caching results. this commit moves calls to rustc queries from `Tables` to `SmirCtxt`.

Author: makai410

compiler/rustc_smir/src/rustc_internal/mod.rs

@@ -127,7 +127,7 @@ where
     F: FnOnce() -> T,
 {
     let smir_cx = RefCell::new(SmirCtxt::new(tcx));
-    let container = SmirContainer { tables: RefCell::new(Tables::new(tcx)), cx: smir_cx };
+    let container = SmirContainer { tables: RefCell::new(Tables::default()), cx: smir_cx };
 
     stable_mir::compiler_interface::run(&container, || init(&container, f))
 }

compiler/rustc_smir/src/rustc_smir/alloc.rs

@@ -8,19 +8,28 @@ use rustc_abi::{Size, TyAndLayout};
 use rustc_middle::mir::interpret::{
     AllocId, AllocInit, AllocRange, Allocation, ConstAllocation, Pointer, Scalar, alloc_range,
 };
-use rustc_middle::ty::Ty;
+use rustc_middle::ty::{Ty, layout};
 
-use crate::rustc_smir::{Bridge, SmirError, Tables};
+use super::SmirCtxt;
+use crate::rustc_smir::{Bridge, SmirError};
+
+pub fn create_ty_and_layout<'tcx, B: Bridge>(
+    cx: &SmirCtxt<'tcx, B>,
+    ty: Ty<'tcx>,
+) -> Result<TyAndLayout<'tcx, Ty<'tcx>>, &'tcx layout::LayoutError<'tcx>> {
+    use crate::rustc_smir::context::SmirTypingEnv;
+    cx.tcx.layout_of(cx.fully_monomorphized().as_query_input(ty))
+}
 
 pub fn try_new_scalar<'tcx, B: Bridge>(
     layout: TyAndLayout<'tcx, Ty<'tcx>>,
     scalar: Scalar,
-    tables: &mut Tables<'tcx, B>,
+    cx: &SmirCtxt<'tcx, B>,
 ) -> Result<Allocation, B::Error> {
     let size = scalar.size();
     let mut allocation = Allocation::new(size, layout.align.abi, AllocInit::Uninit);
     allocation
-        .write_scalar(&tables.tcx, alloc_range(Size::ZERO, size), scalar)
+        .write_scalar(&cx.tcx, alloc_range(Size::ZERO, size), scalar)
         .map_err(|e| B::Error::from_internal(e))?;
 
     Ok(allocation)
@@ -30,24 +39,20 @@ pub fn try_new_slice<'tcx, B: Bridge>(
     layout: TyAndLayout<'tcx, Ty<'tcx>>,
     data: ConstAllocation<'tcx>,
     meta: u64,
-    tables: &mut Tables<'tcx, B>,
+    cx: &SmirCtxt<'tcx, B>,
 ) -> Result<Allocation, B::Error> {
-    let alloc_id = tables.tcx.reserve_and_set_memory_alloc(data);
+    let alloc_id = cx.tcx.reserve_and_set_memory_alloc(data);
     let ptr = Pointer::new(alloc_id.into(), Size::ZERO);
-    let scalar_ptr = Scalar::from_pointer(ptr, &tables.tcx);
-    let scalar_meta: Scalar = Scalar::from_target_usize(meta, &tables.tcx);
+    let scalar_ptr = Scalar::from_pointer(ptr, &cx.tcx);
+    let scalar_meta: Scalar = Scalar::from_target_usize(meta, &cx.tcx);
     let mut allocation = Allocation::new(layout.size, layout.align.abi, AllocInit::Uninit);
     allocation
-        .write_scalar(
-            &tables.tcx,
-            alloc_range(Size::ZERO, tables.tcx.data_layout.pointer_size),
-            scalar_ptr,
-        )
+        .write_scalar(&cx.tcx, alloc_range(Size::ZERO, cx.tcx.data_layout.pointer_size), scalar_ptr)
         .map_err(|e| B::Error::from_internal(e))?;
     allocation
         .write_scalar(
-            &tables.tcx,
-            alloc_range(tables.tcx.data_layout.pointer_size, scalar_meta.size()),
+            &cx.tcx,
+            alloc_range(cx.tcx.data_layout.pointer_size, scalar_meta.size()),
             scalar_meta,
         )
         .map_err(|e| B::Error::from_internal(e))?;
@@ -57,9 +62,9 @@ pub fn try_new_slice<'tcx, B: Bridge>(
 
 pub fn try_new_indirect<'tcx, B: Bridge>(
     alloc_id: AllocId,
-    tables: &mut Tables<'tcx, B>,
+    cx: &SmirCtxt<'tcx, B>,
 ) -> ConstAllocation<'tcx> {
-    let alloc = tables.tcx.global_alloc(alloc_id).unwrap_memory();
+    let alloc = cx.tcx.global_alloc(alloc_id).unwrap_memory();
 
     alloc
 }

compiler/rustc_smir/src/rustc_smir/builder.rs

@@ -9,8 +9,6 @@ use rustc_middle::mir;
 use rustc_middle::mir::visit::MutVisitor;
 use rustc_middle::ty::{self, TyCtxt};
 
-use crate::rustc_smir::{Bridge, Tables};
-
 /// Builds a monomorphic body for a given instance.
 pub(crate) struct BodyBuilder<'tcx> {
     tcx: TyCtxt<'tcx>,
@@ -30,16 +28,16 @@ impl<'tcx> BodyBuilder<'tcx> {
     /// Build a stable monomorphic body for a given instance based on the MIR body.
     ///
     /// All constants are also evaluated.
-    pub(crate) fn build<B: Bridge>(mut self, tables: &mut Tables<'tcx, B>) -> mir::Body<'tcx> {
-        let body = tables.tcx.instance_mir(self.instance.def).clone();
+    pub(crate) fn build(mut self) -> mir::Body<'tcx> {
+        let body = self.tcx.instance_mir(self.instance.def).clone();
         let mono_body = if !self.instance.args.is_empty()
             // Without the `generic_const_exprs` feature gate, anon consts in signatures do not
             // get generic parameters. Which is wrong, but also not a problem without
             // generic_const_exprs
             || self.tcx.def_kind(self.instance.def_id()) != DefKind::AnonConst
         {
             let mut mono_body = self.instance.instantiate_mir_and_normalize_erasing_regions(
-                tables.tcx,
+                self.tcx,
                 ty::TypingEnv::fully_monomorphized(),
                 ty::EarlyBinder::bind(body),
             );

compiler/rustc_smir/src/rustc_smir/context/impls.rs

@@ -143,6 +143,46 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
         self.tcx.valtree_to_const_val(key)
     }
 
+    /// Return whether the instance as a body available.
+    ///
+    /// Items and intrinsics may have a body available from its definition.
+    /// Shims body may be generated depending on their type.
+    pub(crate) fn instance_has_body(&self, instance: Instance<'tcx>) -> bool {
+        let def_id = instance.def_id();
+        self.item_has_body(def_id)
+            || !matches!(
+                instance.def,
+                ty::InstanceKind::Virtual(..)
+                    | ty::InstanceKind::Intrinsic(..)
+                    | ty::InstanceKind::Item(..)
+            )
+    }
+
+    /// Return whether the item has a body defined by the user.
+    ///
+    /// Note that intrinsics may have a placeholder body that shouldn't be used in practice.
+    /// In StableMIR, we handle this case as if the body is not available.
+    pub(crate) fn item_has_body(&self, def_id: DefId) -> bool {
+        let must_override = if let Some(intrinsic) = self.tcx.intrinsic(def_id) {
+            intrinsic.must_be_overridden
+        } else {
+            false
+        };
+        !must_override && self.tcx.is_mir_available(def_id)
+    }
+
+    fn filter_fn_def(&self, def_id: DefId) -> Option<DefId> {
+        if matches!(self.tcx.def_kind(def_id), DefKind::Fn | DefKind::AssocFn) {
+            Some(def_id)
+        } else {
+            None
+        }
+    }
+
+    fn filter_static_def(&self, def_id: DefId) -> Option<DefId> {
+        matches!(self.tcx.def_kind(def_id), DefKind::Static { .. }).then(|| def_id)
+    }
+
     pub fn target_endian(&self) -> Endian {
         self.tcx.data_layout.endian
     }
@@ -167,22 +207,22 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
     }
 
     /// Check whether the body of a function is available.
-    pub fn has_body(&self, def: DefId, tables: &mut Tables<'_, B>) -> bool {
-        tables.item_has_body(def)
+    pub fn has_body(&self, def: DefId) -> bool {
+        self.item_has_body(def)
     }
 
     pub fn foreign_modules(&self, crate_num: CrateNum) -> Vec<DefId> {
         self.tcx.foreign_modules(crate_num).keys().map(|mod_def_id| *mod_def_id).collect()
     }
 
     /// Retrieve all functions defined in this crate.
-    pub fn crate_functions(&self, crate_num: CrateNum, tables: &mut Tables<'_, B>) -> Vec<DefId> {
-        filter_def_ids(self.tcx, crate_num, |def_id| tables.filter_fn_def(def_id))
+    pub fn crate_functions(&self, crate_num: CrateNum) -> Vec<DefId> {
+        filter_def_ids(self.tcx, crate_num, |def_id| self.filter_fn_def(def_id))
     }
 
     /// Retrieve all static items defined in this crate.
-    pub fn crate_statics(&self, crate_num: CrateNum, tables: &mut Tables<'_, B>) -> Vec<DefId> {
-        filter_def_ids(self.tcx, crate_num, |def_id| tables.filter_static_def(def_id))
+    pub fn crate_statics(&self, crate_num: CrateNum) -> Vec<DefId> {
+        filter_def_ids(self.tcx, crate_num, |def_id| self.filter_static_def(def_id))
     }
 
     pub fn foreign_module(&self, mod_def: DefId) -> &ForeignModule {
@@ -574,14 +614,8 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
     }
 
     /// Get the body of an Instance which is already monomorphized.
-    pub fn instance_body(
-        &self,
-        instance: ty::Instance<'tcx>,
-        tables: &mut Tables<'tcx, B>,
-    ) -> Option<Body<'tcx>> {
-        tables
-            .instance_has_body(instance)
-            .then(|| BodyBuilder::new(self.tcx, instance).build(tables))
+    pub fn instance_body(&self, instance: ty::Instance<'tcx>) -> Option<Body<'tcx>> {
+        self.instance_has_body(instance).then(|| BodyBuilder::new(self.tcx, instance).build())
     }
 
     /// Get the instance type with generic instantiations applied and lifetimes erased.
@@ -599,18 +633,13 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
     pub fn instance_abi(
         &self,
         instance: ty::Instance<'tcx>,
-        tables: &mut Tables<'tcx, B>,
     ) -> Result<&FnAbi<'tcx, Ty<'tcx>>, B::Error> {
-        Ok(tables.fn_abi_of_instance(instance, List::empty())?)
+        Ok(self.fn_abi_of_instance(instance, List::empty())?)
     }
 
     /// Get the ABI of a function pointer.
-    pub fn fn_ptr_abi(
-        &self,
-        sig: PolyFnSig<'tcx>,
-        tables: &mut Tables<'tcx, B>,
-    ) -> Result<&FnAbi<'tcx, Ty<'tcx>>, B::Error> {
-        Ok(tables.fn_abi_of_fn_ptr(sig, List::empty())?)
+    pub fn fn_ptr_abi(&self, sig: PolyFnSig<'tcx>) -> Result<&FnAbi<'tcx, Ty<'tcx>>, B::Error> {
+        Ok(self.fn_abi_of_fn_ptr(sig, List::empty())?)
     }
 
     /// Get the instance.
@@ -737,12 +766,8 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
     }
 
     /// Get the layout of a type.
-    pub fn ty_layout(
-        &self,
-        ty: Ty<'tcx>,
-        tables: &mut Tables<'tcx, B>,
-    ) -> Result<Layout<'tcx>, B::Error> {
-        let layout = tables.layout_of(ty)?.layout;
+    pub fn ty_layout(&self, ty: Ty<'tcx>) -> Result<Layout<'tcx>, B::Error> {
+        let layout = self.layout_of(ty)?.layout;
         Ok(layout)
     }
 

compiler/rustc_smir/src/rustc_smir/context/mod.rs

@@ -9,7 +9,7 @@ use rustc_middle::ty;
 use rustc_middle::ty::layout::{FnAbiOfHelpers, HasTyCtxt, HasTypingEnv, LayoutOfHelpers};
 use rustc_middle::ty::{Ty, TyCtxt};
 
-use crate::rustc_smir::{Bridge, SmirError, Tables};
+use crate::rustc_smir::{Bridge, SmirError};
 
 mod impls;
 mod traits;
@@ -21,7 +21,7 @@ pub use traits::*;
 /// The [`crate::stable_mir::compiler_interface::SmirInterface`] must go through
 /// this context to obtain rustc-level information.
 pub struct SmirCtxt<'tcx, B: Bridge> {
-    tcx: TyCtxt<'tcx>,
+    pub(crate) tcx: TyCtxt<'tcx>,
     _marker: PhantomData<B>,
 }
 
@@ -32,7 +32,7 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
 }
 
 /// Implement error handling for extracting function ABI information.
-impl<'tcx, B: Bridge> FnAbiOfHelpers<'tcx> for Tables<'tcx, B> {
+impl<'tcx, B: Bridge> FnAbiOfHelpers<'tcx> for SmirCtxt<'tcx, B> {
     type FnAbiOfResult = Result<&'tcx rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>, B::Error>;
 
     #[inline]
@@ -46,7 +46,7 @@ impl<'tcx, B: Bridge> FnAbiOfHelpers<'tcx> for Tables<'tcx, B> {
     }
 }
 
-impl<'tcx, B: Bridge> LayoutOfHelpers<'tcx> for Tables<'tcx, B> {
+impl<'tcx, B: Bridge> LayoutOfHelpers<'tcx> for SmirCtxt<'tcx, B> {
     type LayoutOfResult = Result<ty::layout::TyAndLayout<'tcx>, B::Error>;
 
     #[inline]
@@ -60,19 +60,19 @@ impl<'tcx, B: Bridge> LayoutOfHelpers<'tcx> for Tables<'tcx, B> {
     }
 }
 
-impl<'tcx, B: Bridge> HasTypingEnv<'tcx> for Tables<'tcx, B> {
+impl<'tcx, B: Bridge> HasTypingEnv<'tcx> for SmirCtxt<'tcx, B> {
     fn typing_env(&self) -> ty::TypingEnv<'tcx> {
         ty::TypingEnv::fully_monomorphized()
     }
 }
 
-impl<'tcx, B: Bridge> HasTyCtxt<'tcx> for Tables<'tcx, B> {
+impl<'tcx, B: Bridge> HasTyCtxt<'tcx> for SmirCtxt<'tcx, B> {
     fn tcx(&self) -> TyCtxt<'tcx> {
         self.tcx
     }
 }
 
-impl<'tcx, B: Bridge> HasDataLayout for Tables<'tcx, B> {
+impl<'tcx, B: Bridge> HasDataLayout for SmirCtxt<'tcx, B> {
     fn data_layout(&self) -> &rustc_abi::TargetDataLayout {
         self.tcx.data_layout()
     }

compiler/rustc_smir/src/rustc_smir/mod.rs

@@ -11,10 +11,9 @@ use std::cell::RefCell;
 use std::fmt::Debug;
 
 use context::SmirCtxt;
-use rustc_hir::def::DefKind;
 use rustc_middle::mir;
 use rustc_middle::mir::interpret::AllocId;
-use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
+use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE};
 
 use crate::rustc_internal::IndexMap;
@@ -30,7 +29,6 @@ pub struct SmirContainer<'tcx, B: Bridge> {
 }
 
 pub struct Tables<'tcx, B: Bridge> {
-    tcx: TyCtxt<'tcx>,
     pub(crate) def_ids: IndexMap<DefId, B::DefId>,
     pub(crate) alloc_ids: IndexMap<AllocId, B::AllocId>,
     pub(crate) spans: IndexMap<rustc_span::Span, B::Span>,
@@ -41,10 +39,9 @@ pub struct Tables<'tcx, B: Bridge> {
     pub(crate) layouts: IndexMap<rustc_abi::Layout<'tcx>, B::Layout>,
 }
 
-impl<'tcx, B: Bridge> Tables<'tcx, B> {
-    pub(crate) fn new(tcx: TyCtxt<'tcx>) -> Self {
+impl<'tcx, B: Bridge> Default for Tables<'tcx, B> {
+    fn default() -> Self {
         Self {
-            tcx,
             def_ids: IndexMap::default(),
             alloc_ids: IndexMap::default(),
             spans: IndexMap::default(),
@@ -69,46 +66,6 @@ impl<'tcx, B: Bridge> Tables<'tcx, B> {
     pub(crate) fn intern_mir_const(&mut self, constant: mir::Const<'tcx>) -> B::MirConstId {
         self.mir_consts.create_or_fetch(constant)
     }
-
-    /// Return whether the instance as a body available.
-    ///
-    /// Items and intrinsics may have a body available from its definition.
-    /// Shims body may be generated depending on their type.
-    pub(crate) fn instance_has_body(&self, instance: Instance<'tcx>) -> bool {
-        let def_id = instance.def_id();
-        self.item_has_body(def_id)
-            || !matches!(
-                instance.def,
-                ty::InstanceKind::Virtual(..)
-                    | ty::InstanceKind::Intrinsic(..)
-                    | ty::InstanceKind::Item(..)
-            )
-    }
-
-    /// Return whether the item has a body defined by the user.
-    ///
-    /// Note that intrinsics may have a placeholder body that shouldn't be used in practice.
-    /// In StableMIR, we handle this case as if the body is not available.
-    pub(crate) fn item_has_body(&self, def_id: DefId) -> bool {
-        let must_override = if let Some(intrinsic) = self.tcx.intrinsic(def_id) {
-            intrinsic.must_be_overridden
-        } else {
-            false
-        };
-        !must_override && self.tcx.is_mir_available(def_id)
-    }
-
-    fn filter_fn_def(&mut self, def_id: DefId) -> Option<DefId> {
-        if matches!(self.tcx.def_kind(def_id), DefKind::Fn | DefKind::AssocFn) {
-            Some(def_id)
-        } else {
-            None
-        }
-    }
-
-    fn filter_static_def(&mut self, def_id: DefId) -> Option<DefId> {
-        matches!(self.tcx.def_kind(def_id), DefKind::Static { .. }).then(|| def_id)
-    }
 }
 
 /// A trait defining types that are used to emulate StableMIR components, which is really