fix: resolve the unsoundness

add a new trait `InternalCx`, which defines the methods that are fine to call from `RustcInternal`. `RustcInternal::internal()` then takes a `impl InternalCx<'tcx>` instead of `TyCtxt<'tcx>`.

make `tcx` in `SmirCtxt` public, since we need to pass it to `RustcInternal::internal()` in `SmirInterface`.

Author: makai410

compiler/rustc_smir/src/rustc_internal/mod.rs

@@ -43,11 +43,14 @@ pub fn stable<'tcx, S: Stable<'tcx>>(item: S) -> S::T {
 /// # Panics
 ///
 /// This function will panic if StableMIR has not been properly initialized.
-pub fn internal<'tcx, S>(item: S) -> S::T<'tcx>
+pub fn internal<'tcx, S>(tcx: TyCtxt<'tcx>, item: S) -> S::T<'tcx>
 where
     S: RustcInternal,
 {
-    with_container(|tables, cx| item.internal(tables, cx))
+    // The tcx argument ensures that the item won't outlive the type context.
+    // See https://github.com/rust-lang/rust/pull/120128/commits/9aace6723572438a94378451793ca37deb768e72
+    // for more details.
+    with_container(|tables, _| item.internal(tables, tcx))
 }
 
 pub fn crate_num(item: &stable_mir::Crate) -> CrateNum {
@@ -69,14 +72,14 @@ where
 
 /// Loads the current context and calls a function with it.
 /// Do not nest these, as that will ICE.
-pub(crate) fn with_container<'tcx, R, B: Bridge>(
-    f: impl FnOnce(&mut Tables<'tcx, B>, &SmirCtxt<'tcx, B>) -> R,
+pub(crate) fn with_container<R, B: Bridge>(
+    f: impl for<'tcx> FnOnce(&mut Tables<'tcx, B>, &SmirCtxt<'tcx, B>) -> R,
 ) -> R {
     assert!(TLV.is_set());
     TLV.with(|tlv| {
         let ptr = tlv.get();
         assert!(!ptr.is_null());
-        let container = ptr as *const SmirContainer<'tcx, B>;
+        let container = ptr as *const SmirContainer<'_, B>;
         let mut tables = unsafe { (*container).tables.borrow_mut() };
         let cx = unsafe { (*container).cx.borrow() };
         f(&mut *tables, &*cx)

compiler/rustc_smir/src/rustc_smir/alloc.rs

@@ -43,8 +43,8 @@ pub fn try_new_slice<'tcx, B: Bridge>(
 ) -> Result<Allocation, B::Error> {
     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(&cx.tcx, alloc_range(Size::ZERO, cx.tcx.data_layout.pointer_size), scalar_ptr)

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

@@ -25,44 +25,10 @@ use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use rustc_span::{FileNameDisplayPreference, Span, Symbol};
 use rustc_target::callconv::FnAbi;
 
-use super::{
-    SmirAllocRange, SmirCtxt, SmirExistentialProjection, SmirExistentialTraitRef, SmirRegion,
-    SmirTraitRef, SmirTy, SmirTypingEnv,
-};
+use super::{SmirAllocRange, SmirCtxt, SmirTy, SmirTypingEnv};
 use crate::rustc_smir::builder::BodyBuilder;
 use crate::rustc_smir::{Bridge, SmirError, Tables, filter_def_ids};
 
-impl<'tcx, B: Bridge> SmirExistentialProjection<'tcx> for SmirCtxt<'tcx, B> {
-    fn new_from_args(
-        &self,
-        def_id: rustc_span::def_id::DefId,
-        args: ty::GenericArgsRef<'tcx>,
-        term: ty::Term<'tcx>,
-    ) -> ty::ExistentialProjection<'tcx> {
-        ty::ExistentialProjection::new_from_args(self.tcx, def_id, args, term)
-    }
-}
-
-impl<'tcx, B: Bridge> SmirExistentialTraitRef<'tcx> for SmirCtxt<'tcx, B> {
-    fn new_from_args(
-        &self,
-        trait_def_id: DefId,
-        args: ty::GenericArgsRef<'tcx>,
-    ) -> ty::ExistentialTraitRef<'tcx> {
-        ty::ExistentialTraitRef::new_from_args(self.tcx, trait_def_id, args)
-    }
-}
-
-impl<'tcx, B: Bridge> SmirTraitRef<'tcx> for SmirCtxt<'tcx, B> {
-    fn new_from_args(
-        &self,
-        trait_def_id: DefId,
-        args: ty::GenericArgsRef<'tcx>,
-    ) -> ty::TraitRef<'tcx> {
-        ty::TraitRef::new_from_args(self.tcx, trait_def_id, args)
-    }
-}
-
 impl<'tcx, B: Bridge> SmirTy<'tcx> for SmirCtxt<'tcx, B> {
     fn new_foreign(&self, def_id: DefId) -> ty::Ty<'tcx> {
         ty::Ty::new_foreign(self.tcx, def_id)
@@ -85,52 +51,11 @@ impl<'tcx, B: Bridge> SmirAllocRange<'tcx> for SmirCtxt<'tcx, B> {
     }
 }
 
-impl<'tcx, B: Bridge> SmirRegion<'tcx> for SmirCtxt<'tcx, B> {
-    fn lifetimes_re_erased(&self) -> ty::Region<'tcx> {
-        self.tcx.lifetimes.re_erased
-    }
-}
-
 impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
     pub fn lift<T: ty::Lift<TyCtxt<'tcx>>>(&self, value: T) -> Option<T::Lifted> {
         self.tcx.lift(value)
     }
 
-    pub fn mk_args_from_iter<I, T>(&self, iter: I) -> T::Output
-    where
-        I: Iterator<Item = T>,
-        T: ty::CollectAndApply<ty::GenericArg<'tcx>, ty::GenericArgsRef<'tcx>>,
-    {
-        self.tcx.mk_args_from_iter(iter)
-    }
-
-    pub fn mk_pat(&self, v: ty::PatternKind<'tcx>) -> ty::Pattern<'tcx> {
-        self.tcx.mk_pat(v)
-    }
-
-    pub fn mk_poly_existential_predicates(
-        &self,
-        eps: &[ty::PolyExistentialPredicate<'tcx>],
-    ) -> &'tcx List<ty::PolyExistentialPredicate<'tcx>> {
-        self.tcx.mk_poly_existential_predicates(eps)
-    }
-
-    pub fn mk_type_list(&self, v: &[Ty<'tcx>]) -> &'tcx List<Ty<'tcx>> {
-        self.tcx.mk_type_list(v)
-    }
-
-    pub fn mk_bound_variable_kinds_from_iter<I, T>(&self, iter: I) -> T::Output
-    where
-        I: Iterator<Item = T>,
-        T: ty::CollectAndApply<ty::BoundVariableKind, &'tcx List<ty::BoundVariableKind>>,
-    {
-        self.tcx.mk_bound_variable_kinds_from_iter(iter)
-    }
-
-    pub fn mk_place_elems(&self, v: &[mir::PlaceElem<'tcx>]) -> &'tcx List<mir::PlaceElem<'tcx>> {
-        self.tcx.mk_place_elems(v)
-    }
-
     pub fn adt_def(&self, def_id: DefId) -> AdtDef<'tcx> {
         self.tcx.adt_def(def_id)
     }

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

@@ -21,12 +21,12 @@ 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> {
-    pub(crate) tcx: TyCtxt<'tcx>,
+    pub tcx: TyCtxt<'tcx>,
     _marker: PhantomData<B>,
 }
 
 impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> {
-    pub(crate) fn new(tcx: TyCtxt<'tcx>) -> Self {
+    pub fn new(tcx: TyCtxt<'tcx>) -> Self {
         Self { tcx, _marker: Default::default() }
     }
 }

compiler/rustc_smir/src/rustc_smir/context/traits.rs

@@ -44,7 +44,3 @@ pub trait SmirTypingEnv<'tcx> {
 pub trait SmirAllocRange<'tcx> {
     fn alloc_range(&self, offset: rustc_abi::Size, size: rustc_abi::Size) -> AllocRange;
 }
-
-pub trait SmirRegion<'tcx> {
-    fn lifetimes_re_erased(&self) -> ty::Region<'tcx>;
-}