nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Ensure internal function is safe

Browse Source 
The internal function was unsound, it could cause UB in rare cases where
the user inadvertly stored the returned object in a location that could
outlive the TyCtxt.

In order to make it safe, we now take a type context as an argument to
the internal fn, and we ensure that interned items are lifted using the
provided context.

Thus, this change ensures that the compiler can properly enforce
that the object does not outlive the type context it was lifted to.
This commit is contained in:
Celina G. Val 2024-01-17 18:35:19 -08:00 committed by Oli Scherer
parent 61361c16aa
commit 9aace67235
5 changed files with 296 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

333
compiler/rustc_smir/src/rustc_internal/internal.rs
View File

@ -5,7 +5,7 @@
// Prefer importing stable_mir over internal rustc constructs to make this file more readable. // Prefer importing stable_mir over internal rustc constructs to make this file more readable.
use crate::rustc_smir::Tables; use crate::rustc_smir::Tables;
use rustc_middle::ty::{self as rustc_ty, Ty as InternalTy}; use rustc_middle::ty::{self as rustc_ty, Ty as InternalTy, TyCtxt};
use rustc_span::Symbol; use rustc_span::Symbol;
use stable_mir::abi::Layout; use stable_mir::abi::Layout;
use stable_mir::mir::alloc::AllocId; use stable_mir::mir::alloc::AllocId;
@ -21,118 +21,120 @@ use stable_mir::{CrateItem, CrateNum, DefId};
use super::RustcInternal; use super::RustcInternal;
impl<'tcx> RustcInternal<'tcx> for CrateItem { unsafe impl<'tcx> RustcInternal<'tcx> for CrateItem {
type T = rustc_span::def_id::DefId; type T = rustc_span::def_id::DefId;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
self.0.internal(tables) self.0.internal(tables, tcx)
} }
} }
impl<'tcx> RustcInternal<'tcx> for CrateNum { unsafe impl<'tcx> RustcInternal<'tcx> for CrateNum {
type T = rustc_span::def_id::CrateNum; type T = rustc_span::def_id::CrateNum;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
rustc_span::def_id::CrateNum::from_usize(*self) rustc_span::def_id::CrateNum::from_usize(*self)
} }
} }
impl<'tcx> RustcInternal<'tcx> for DefId { unsafe impl<'tcx> RustcInternal<'tcx> for DefId {
type T = rustc_span::def_id::DefId; type T = rustc_span::def_id::DefId;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
tables.def_ids[*self] tcx.lift(tables.def_ids[*self]).unwrap()
} }
} }
impl<'tcx> RustcInternal<'tcx> for GenericArgs { unsafe impl<'tcx> RustcInternal<'tcx> for GenericArgs {
type T = rustc_ty::GenericArgsRef<'tcx>; type T = rustc_ty::GenericArgsRef<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
tables.tcx.mk_args_from_iter(self.0.iter().map(|arg| arg.internal(tables))) tcx.mk_args_from_iter(self.0.iter().map(|arg| arg.internal(tables, tcx)))
} }
} }
impl<'tcx> RustcInternal<'tcx> for GenericArgKind { unsafe impl<'tcx> RustcInternal<'tcx> for GenericArgKind {
type T = rustc_ty::GenericArg<'tcx>; type T = rustc_ty::GenericArg<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
match self { let arg: rustc_ty::GenericArg<'tcx> = match self {
GenericArgKind::Lifetime(reg) => reg.internal(tables).into(), GenericArgKind::Lifetime(reg) => reg.internal(tables, tcx).into(),
GenericArgKind::Type(ty) => ty.internal(tables).into(), GenericArgKind::Type(ty) => ty.internal(tables, tcx).into(),
GenericArgKind::Const(cnst) => ty_const(cnst, tables).into(), GenericArgKind::Const(cnst) => ty_const(cnst, tables, tcx).into(),
} };
tcx.lift(arg).unwrap()
} }
} }
impl<'tcx> RustcInternal<'tcx> for Region { unsafe impl<'tcx> RustcInternal<'tcx> for Region {
type T = rustc_ty::Region<'tcx>; type T = rustc_ty::Region<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
// Cannot recover region. Use erased instead. // Cannot recover region. Use erased for now.
tables.tcx.lifetimes.re_erased tcx.lifetimes.re_erased
} }
} }
impl<'tcx> RustcInternal<'tcx> for Ty { unsafe impl<'tcx> RustcInternal<'tcx> for Ty {
type T = InternalTy<'tcx>; type T = InternalTy<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
tables.types[*self] tcx.lift(tables.types[*self]).unwrap()
} }
} }
impl<'tcx> RustcInternal<'tcx> for RigidTy { unsafe impl<'tcx> RustcInternal<'tcx> for RigidTy {
type T = rustc_ty::TyKind<'tcx>; type T = rustc_ty::TyKind<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
RigidTy::Bool => rustc_ty::TyKind::Bool, RigidTy::Bool => rustc_ty::TyKind::Bool,
RigidTy::Char => rustc_ty::TyKind::Char, RigidTy::Char => rustc_ty::TyKind::Char,
RigidTy::Int(int_ty) => rustc_ty::TyKind::Int(int_ty.internal(tables)), RigidTy::Int(int_ty) => rustc_ty::TyKind::Int(int_ty.internal(tables, tcx)),
RigidTy::Uint(uint_ty) => rustc_ty::TyKind::Uint(uint_ty.internal(tables)), RigidTy::Uint(uint_ty) => rustc_ty::TyKind::Uint(uint_ty.internal(tables, tcx)),
RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables)), RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables, tcx)),
RigidTy::Never => rustc_ty::TyKind::Never, RigidTy::Never => rustc_ty::TyKind::Never,
RigidTy::Array(ty, cnst) => { RigidTy::Array(ty, cnst) => {
rustc_ty::TyKind::Array(ty.internal(tables), ty_const(cnst, tables)) rustc_ty::TyKind::Array(ty.internal(tables, tcx), ty_const(cnst, tables, tcx))
} }
RigidTy::Adt(def, args) => { RigidTy::Adt(def, args) => {
rustc_ty::TyKind::Adt(def.internal(tables), args.internal(tables)) rustc_ty::TyKind::Adt(def.internal(tables, tcx), args.internal(tables, tcx))
} }
RigidTy::Str => rustc_ty::TyKind::Str, RigidTy::Str => rustc_ty::TyKind::Str,
RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables)), RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, tcx)),
RigidTy::RawPtr(ty, mutability) => rustc_ty::TyKind::RawPtr(rustc_ty::TypeAndMut { RigidTy::RawPtr(ty, mutability) => rustc_ty::TyKind::RawPtr(rustc_ty::TypeAndMut {
ty: ty.internal(tables), ty: ty.internal(tables, tcx),
mutbl: mutability.internal(tables), mutbl: mutability.internal(tables, tcx),
}), }),
RigidTy::Ref(region, ty, mutability) => rustc_ty::TyKind::Ref( RigidTy::Ref(region, ty, mutability) => rustc_ty::TyKind::Ref(
region.internal(tables), region.internal(tables, tcx),
ty.internal(tables), ty.internal(tables, tcx),
mutability.internal(tables), mutability.internal(tables, tcx),
), ),
RigidTy::Foreign(def) => rustc_ty::TyKind::Foreign(def.0.internal(tables)), RigidTy::Foreign(def) => rustc_ty::TyKind::Foreign(def.0.internal(tables, tcx)),
RigidTy::FnDef(def, args) => { RigidTy::FnDef(def, args) => {
rustc_ty::TyKind::FnDef(def.0.internal(tables), args.internal(tables)) rustc_ty::TyKind::FnDef(def.0.internal(tables, tcx), args.internal(tables, tcx))
} }
RigidTy::FnPtr(sig) => rustc_ty::TyKind::FnPtr(sig.internal(tables)), RigidTy::FnPtr(sig) => rustc_ty::TyKind::FnPtr(sig.internal(tables, tcx)),
RigidTy::Closure(def, args) => { RigidTy::Closure(def, args) => {
rustc_ty::TyKind::Closure(def.0.internal(tables), args.internal(tables)) rustc_ty::TyKind::Closure(def.0.internal(tables, tcx), args.internal(tables, tcx))
} }
RigidTy::Coroutine(def, args, _mov) => { RigidTy::Coroutine(def, args, _mov) => {
rustc_ty::TyKind::Coroutine(def.0.internal(tables), args.internal(tables)) rustc_ty::TyKind::Coroutine(def.0.internal(tables, tcx), args.internal(tables, tcx))
}
RigidTy::CoroutineWitness(def, args) => {
rustc_ty::TyKind::CoroutineWitness(def.0.internal(tables), args.internal(tables))
} }
RigidTy::CoroutineWitness(def, args) => rustc_ty::TyKind::CoroutineWitness(
def.0.internal(tables, tcx),
args.internal(tables, tcx),
),
RigidTy::Dynamic(predicate, region, dyn_kind) => rustc_ty::TyKind::Dynamic( RigidTy::Dynamic(predicate, region, dyn_kind) => rustc_ty::TyKind::Dynamic(
tables.tcx.mk_poly_existential_predicates(&predicate.internal(tables)), tcx.mk_poly_existential_predicates(&predicate.internal(tables, tcx)),
region.internal(tables), region.internal(tables, tcx),
dyn_kind.internal(tables), dyn_kind.internal(tables, tcx),
), ),
RigidTy::Tuple(tys) => { RigidTy::Tuple(tys) => {
rustc_ty::TyKind::Tuple(tables.tcx.mk_type_list(&tys.internal(tables))) rustc_ty::TyKind::Tuple(tcx.mk_type_list(&tys.internal(tables, tcx)))
} }
} }
} }
} }
impl<'tcx> RustcInternal<'tcx> for IntTy { unsafe impl<'tcx> RustcInternal<'tcx> for IntTy {
type T = rustc_ty::IntTy; type T = rustc_ty::IntTy;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
IntTy::Isize => rustc_ty::IntTy::Isize, IntTy::Isize => rustc_ty::IntTy::Isize,
IntTy::I8 => rustc_ty::IntTy::I8, IntTy::I8 => rustc_ty::IntTy::I8,
@ -144,10 +146,10 @@ impl<'tcx> RustcInternal<'tcx> for IntTy {
} }
} }
impl<'tcx> RustcInternal<'tcx> for UintTy { unsafe impl<'tcx> RustcInternal<'tcx> for UintTy {
type T = rustc_ty::UintTy; type T = rustc_ty::UintTy;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
UintTy::Usize => rustc_ty::UintTy::Usize, UintTy::Usize => rustc_ty::UintTy::Usize,
UintTy::U8 => rustc_ty::UintTy::U8, UintTy::U8 => rustc_ty::UintTy::U8,
@ -159,10 +161,10 @@ impl<'tcx> RustcInternal<'tcx> for UintTy {
} }
} }
impl<'tcx> RustcInternal<'tcx> for FloatTy { unsafe impl<'tcx> RustcInternal<'tcx> for FloatTy {
type T = rustc_ty::FloatTy; type T = rustc_ty::FloatTy;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
FloatTy::F32 => rustc_ty::FloatTy::F32, FloatTy::F32 => rustc_ty::FloatTy::F32,
FloatTy::F64 => rustc_ty::FloatTy::F64, FloatTy::F64 => rustc_ty::FloatTy::F64,
@ -170,10 +172,10 @@ impl<'tcx> RustcInternal<'tcx> for FloatTy {
} }
} }
impl<'tcx> RustcInternal<'tcx> for Mutability { unsafe impl<'tcx> RustcInternal<'tcx> for Mutability {
type T = rustc_ty::Mutability; type T = rustc_ty::Mutability;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
Mutability::Not => rustc_ty::Mutability::Not, Mutability::Not => rustc_ty::Mutability::Not,
Mutability::Mut => rustc_ty::Mutability::Mut, Mutability::Mut => rustc_ty::Mutability::Mut,
@ -181,10 +183,10 @@ impl<'tcx> RustcInternal<'tcx> for Mutability {
} }
} }
impl<'tcx> RustcInternal<'tcx> for Movability { unsafe impl<'tcx> RustcInternal<'tcx> for Movability {
type T = rustc_ty::Movability; type T = rustc_ty::Movability;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
Movability::Static => rustc_ty::Movability::Static, Movability::Static => rustc_ty::Movability::Static,
Movability::Movable => rustc_ty::Movability::Movable, Movability::Movable => rustc_ty::Movability::Movable,
@ -192,37 +194,44 @@ impl<'tcx> RustcInternal<'tcx> for Movability {
} }
} }
impl<'tcx> RustcInternal<'tcx> for FnSig { unsafe impl<'tcx> RustcInternal<'tcx> for FnSig {
type T = rustc_ty::FnSig<'tcx>; type T = rustc_ty::FnSig<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
rustc_ty::FnSig { tcx.lift(rustc_ty::FnSig {
inputs_and_output: tables.tcx.mk_type_list(&self.inputs_and_output.internal(tables)), inputs_and_output: tables
.tcx
.mk_type_list(&self.inputs_and_output.internal(tables, tcx)),
c_variadic: self.c_variadic, c_variadic: self.c_variadic,
unsafety: self.unsafety.internal(tables), unsafety: self.unsafety.internal(tables, tcx),
abi: self.abi.internal(tables), abi: self.abi.internal(tables, tcx),
} })
.unwrap()
} }
} }
impl<'tcx> RustcInternal<'tcx> for VariantIdx { unsafe impl<'tcx> RustcInternal<'tcx> for VariantIdx {
type T = rustc_target::abi::VariantIdx; type T = rustc_target::abi::VariantIdx;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
rustc_target::abi::VariantIdx::from(self.to_index()) rustc_target::abi::VariantIdx::from(self.to_index())
} }
} }
impl<'tcx> RustcInternal<'tcx> for VariantDef { unsafe impl<'tcx> RustcInternal<'tcx> for VariantDef {
type T = &'tcx rustc_ty::VariantDef; type T = &'tcx rustc_ty::VariantDef;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
self.adt_def.internal(tables).variant(self.idx.internal(tables)) self.adt_def.internal(tables, tcx).variant(self.idx.internal(tables, tcx))
} }
} }
fn ty_const<'tcx>(constant: &Const, tables: &mut Tables<'tcx>) -> rustc_ty::Const<'tcx> { fn ty_const<'tcx>(
match constant.internal(tables) { constant: &Const,
tables: &mut Tables<'tcx>,
tcx: TyCtxt<'tcx>,
) -> rustc_ty::Const<'tcx> {
match constant.internal(tables, tcx) {
rustc_middle::mir::Const::Ty(c) => c, rustc_middle::mir::Const::Ty(c) => c,
cnst => { cnst => {
panic!("Trying to convert constant `{constant:?}` to type constant, but found {cnst:?}") panic!("Trying to convert constant `{constant:?}` to type constant, but found {cnst:?}")
@ -230,21 +239,33 @@ fn ty_const<'tcx>(constant: &Const, tables: &mut Tables<'tcx>) -> rustc_ty::Cons
} }
} }
impl<'tcx> RustcInternal<'tcx> for Const { unsafe impl<'tcx> RustcInternal<'tcx> for Const {
type T = rustc_middle::mir::Const<'tcx>; type T = rustc_middle::mir::Const<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
tables.constants[self.id] let constant = tables.constants[self.id];
match constant {
rustc_middle::mir::Const::Ty(ty) => rustc_middle::mir::Const::Ty(tcx.lift(ty).unwrap()),
rustc_middle::mir::Const::Unevaluated(uneval, ty) => {
rustc_middle::mir::Const::Unevaluated(
lift_unevaluated(tcx, uneval),
tcx.lift(ty).unwrap(),
)
}
rustc_middle::mir::Const::Val(const_val, ty) => {
rustc_middle::mir::Const::Val(tcx.lift(const_val).unwrap(), tcx.lift(ty).unwrap())
}
}
} }
} }
impl<'tcx> RustcInternal<'tcx> for MonoItem { unsafe impl<'tcx> RustcInternal<'tcx> for MonoItem {
type T = rustc_middle::mir::mono::MonoItem<'tcx>; type T = rustc_middle::mir::mono::MonoItem<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
use rustc_middle::mir::mono as rustc_mono; use rustc_middle::mir::mono as rustc_mono;
match self { match self {
MonoItem::Fn(instance) => rustc_mono::MonoItem::Fn(instance.internal(tables)), MonoItem::Fn(instance) => rustc_mono::MonoItem::Fn(instance.internal(tables, tcx)),
MonoItem::Static(def) => rustc_mono::MonoItem::Static(def.internal(tables)), MonoItem::Static(def) => rustc_mono::MonoItem::Static(def.internal(tables, tcx)),
MonoItem::GlobalAsm(_) => { MonoItem::GlobalAsm(_) => {
unimplemented!() unimplemented!()
} }
@ -252,55 +273,56 @@ impl<'tcx> RustcInternal<'tcx> for MonoItem {
} }
} }
impl<'tcx> RustcInternal<'tcx> for Instance { unsafe impl<'tcx> RustcInternal<'tcx> for Instance {
type T = rustc_ty::Instance<'tcx>; type T = rustc_ty::Instance<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
tables.instances[self.def] tcx.lift(tables.instances[self.def]).unwrap()
} }
} }
impl<'tcx> RustcInternal<'tcx> for StaticDef { unsafe impl<'tcx> RustcInternal<'tcx> for StaticDef {
type T = rustc_span::def_id::DefId; type T = rustc_span::def_id::DefId;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
self.0.internal(tables) self.0.internal(tables, tcx)
} }
} }
#[allow(rustc::usage_of_qualified_ty)] #[allow(rustc::usage_of_qualified_ty)]
impl<'tcx, T> RustcInternal<'tcx> for Binder<T> unsafe impl<'tcx, T> RustcInternal<'tcx> for Binder<T>
where where
T: RustcInternal<'tcx>, T: RustcInternal<'tcx>,
T::T: rustc_ty::TypeVisitable<rustc_ty::TyCtxt<'tcx>>, T::T: rustc_ty::TypeVisitable<rustc_ty::TyCtxt<'tcx>>,
{ {
type T = rustc_ty::Binder<'tcx, T::T>; type T = rustc_ty::Binder<'tcx, T::T>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
rustc_ty::Binder::bind_with_vars( rustc_ty::Binder::bind_with_vars(
self.value.internal(tables), self.value.internal(tables, tcx),
tables.tcx.mk_bound_variable_kinds_from_iter( tcx.mk_bound_variable_kinds_from_iter(
self.bound_vars.iter().map(|bound| bound.internal(tables)), self.bound_vars.iter().map(|bound| bound.internal(tables, tcx)),
), ),
) )
} }
} }
impl<'tcx> RustcInternal<'tcx> for BoundVariableKind { unsafe impl<'tcx> RustcInternal<'tcx> for BoundVariableKind {
type T = rustc_ty::BoundVariableKind; type T = rustc_ty::BoundVariableKind;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
BoundVariableKind::Ty(kind) => rustc_ty::BoundVariableKind::Ty(match kind { BoundVariableKind::Ty(kind) => rustc_ty::BoundVariableKind::Ty(match kind {
BoundTyKind::Anon => rustc_ty::BoundTyKind::Anon, BoundTyKind::Anon => rustc_ty::BoundTyKind::Anon,
BoundTyKind::Param(def, symbol) => { BoundTyKind::Param(def, symbol) => rustc_ty::BoundTyKind::Param(
rustc_ty::BoundTyKind::Param(def.0.internal(tables), Symbol::intern(symbol)) def.0.internal(tables, tcx),
} Symbol::intern(symbol),
),
}), }),
BoundVariableKind::Region(kind) => rustc_ty::BoundVariableKind::Region(match kind { BoundVariableKind::Region(kind) => rustc_ty::BoundVariableKind::Region(match kind {
BoundRegionKind::BrAnon => rustc_ty::BoundRegionKind::BrAnon, BoundRegionKind::BrAnon => rustc_ty::BoundRegionKind::BrAnon,
BoundRegionKind::BrNamed(def, symbol) => rustc_ty::BoundRegionKind::BrNamed( BoundRegionKind::BrNamed(def, symbol) => rustc_ty::BoundRegionKind::BrNamed(
def.0.internal(tables), def.0.internal(tables, tcx),
Symbol::intern(symbol), Symbol::intern(symbol),
), ),
BoundRegionKind::BrEnv => rustc_ty::BoundRegionKind::BrEnv, BoundRegionKind::BrEnv => rustc_ty::BoundRegionKind::BrEnv,
@ -310,10 +332,10 @@ impl<'tcx> RustcInternal<'tcx> for BoundVariableKind {
} }
} }
impl<'tcx> RustcInternal<'tcx> for DynKind { unsafe impl<'tcx> RustcInternal<'tcx> for DynKind {
type T = rustc_ty::DynKind; type T = rustc_ty::DynKind;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
DynKind::Dyn => rustc_ty::DynKind::Dyn, DynKind::Dyn => rustc_ty::DynKind::Dyn,
DynKind::DynStar => rustc_ty::DynKind::DynStar, DynKind::DynStar => rustc_ty::DynKind::DynStar,
@ -321,81 +343,81 @@ impl<'tcx> RustcInternal<'tcx> for DynKind {
} }
} }
impl<'tcx> RustcInternal<'tcx> for ExistentialPredicate { unsafe impl<'tcx> RustcInternal<'tcx> for ExistentialPredicate {
type T = rustc_ty::ExistentialPredicate<'tcx>; type T = rustc_ty::ExistentialPredicate<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
ExistentialPredicate::Trait(trait_ref) => { ExistentialPredicate::Trait(trait_ref) => {
rustc_ty::ExistentialPredicate::Trait(trait_ref.internal(tables)) rustc_ty::ExistentialPredicate::Trait(trait_ref.internal(tables, tcx))
} }
ExistentialPredicate::Projection(proj) => { ExistentialPredicate::Projection(proj) => {
rustc_ty::ExistentialPredicate::Projection(proj.internal(tables)) rustc_ty::ExistentialPredicate::Projection(proj.internal(tables, tcx))
} }
ExistentialPredicate::AutoTrait(trait_def) => { ExistentialPredicate::AutoTrait(trait_def) => {
rustc_ty::ExistentialPredicate::AutoTrait(trait_def.0.internal(tables)) rustc_ty::ExistentialPredicate::AutoTrait(trait_def.0.internal(tables, tcx))
} }
} }
} }
} }
impl<'tcx> RustcInternal<'tcx> for ExistentialProjection { unsafe impl<'tcx> RustcInternal<'tcx> for ExistentialProjection {
type T = rustc_ty::ExistentialProjection<'tcx>; type T = rustc_ty::ExistentialProjection<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
rustc_ty::ExistentialProjection { rustc_ty::ExistentialProjection {
def_id: self.def_id.0.internal(tables), def_id: self.def_id.0.internal(tables, tcx),
args: self.generic_args.internal(tables), args: self.generic_args.internal(tables, tcx),
term: self.term.internal(tables), term: self.term.internal(tables, tcx),
} }
} }
} }
impl<'tcx> RustcInternal<'tcx> for TermKind { unsafe impl<'tcx> RustcInternal<'tcx> for TermKind {
type T = rustc_ty::Term<'tcx>; type T = rustc_ty::Term<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
TermKind::Type(ty) => ty.internal(tables).into(), TermKind::Type(ty) => ty.internal(tables, tcx).into(),
TermKind::Const(const_) => ty_const(const_, tables).into(), TermKind::Const(const_) => ty_const(const_, tables, tcx).into(),
} }
} }
} }
impl<'tcx> RustcInternal<'tcx> for ExistentialTraitRef { unsafe impl<'tcx> RustcInternal<'tcx> for ExistentialTraitRef {
type T = rustc_ty::ExistentialTraitRef<'tcx>; type T = rustc_ty::ExistentialTraitRef<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
rustc_ty::ExistentialTraitRef { rustc_ty::ExistentialTraitRef {
def_id: self.def_id.0.internal(tables), def_id: self.def_id.0.internal(tables, tcx),
args: self.generic_args.internal(tables), args: self.generic_args.internal(tables, tcx),
} }
} }
} }
impl<'tcx> RustcInternal<'tcx> for TraitRef { unsafe impl<'tcx> RustcInternal<'tcx> for TraitRef {
type T = rustc_ty::TraitRef<'tcx>; type T = rustc_ty::TraitRef<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
rustc_ty::TraitRef::new( rustc_ty::TraitRef::new(
tables.tcx, tcx,
self.def_id.0.internal(tables), self.def_id.0.internal(tables, tcx),
self.args().internal(tables), self.args().internal(tables, tcx),
) )
} }
} }
impl<'tcx> RustcInternal<'tcx> for AllocId { unsafe impl<'tcx> RustcInternal<'tcx> for AllocId {
type T = rustc_middle::mir::interpret::AllocId; type T = rustc_middle::mir::interpret::AllocId;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
tables.alloc_ids[*self] tcx.lift(tables.alloc_ids[*self]).unwrap()
} }
} }
impl<'tcx> RustcInternal<'tcx> for ClosureKind { unsafe impl<'tcx> RustcInternal<'tcx> for ClosureKind {
type T = rustc_ty::ClosureKind; type T = rustc_ty::ClosureKind;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
ClosureKind::Fn => rustc_ty::ClosureKind::Fn, ClosureKind::Fn => rustc_ty::ClosureKind::Fn,
ClosureKind::FnMut => rustc_ty::ClosureKind::FnMut, ClosureKind::FnMut => rustc_ty::ClosureKind::FnMut,
@ -404,17 +426,17 @@ impl<'tcx> RustcInternal<'tcx> for ClosureKind {
} }
} }
impl<'tcx> RustcInternal<'tcx> for AdtDef { unsafe impl<'tcx> RustcInternal<'tcx> for AdtDef {
type T = rustc_ty::AdtDef<'tcx>; type T = rustc_ty::AdtDef<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
tables.tcx.adt_def(self.0.internal(&mut *tables)) tcx.adt_def(self.0.internal(tables, tcx))
} }
} }
impl<'tcx> RustcInternal<'tcx> for Abi { unsafe impl<'tcx> RustcInternal<'tcx> for Abi {
type T = rustc_target::spec::abi::Abi; type T = rustc_target::spec::abi::Abi;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
match *self { match *self {
Abi::Rust => rustc_target::spec::abi::Abi::Rust, Abi::Rust => rustc_target::spec::abi::Abi::Rust,
Abi::C { unwind } => rustc_target::spec::abi::Abi::C { unwind }, Abi::C { unwind } => rustc_target::spec::abi::Abi::C { unwind },
@ -447,10 +469,10 @@ impl<'tcx> RustcInternal<'tcx> for Abi {
} }
} }
impl<'tcx> RustcInternal<'tcx> for Safety { unsafe impl<'tcx> RustcInternal<'tcx> for Safety {
type T = rustc_hir::Unsafety; type T = rustc_hir::Unsafety;
fn internal(&self, _tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, _tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
match self { match self {
Safety::Unsafe => rustc_hir::Unsafety::Unsafe, Safety::Unsafe => rustc_hir::Unsafety::Unsafe,
Safety::Normal => rustc_hir::Unsafety::Normal, Safety::Normal => rustc_hir::Unsafety::Normal,
@ -458,51 +480,62 @@ impl<'tcx> RustcInternal<'tcx> for Safety {
} }
} }
impl<'tcx> RustcInternal<'tcx> for Span { unsafe impl<'tcx> RustcInternal<'tcx> for Span {
type T = rustc_span::Span; type T = rustc_span::Span;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, _tcx: TyCtxt<'tcx>) -> Self::T {
tables[*self] tables[*self]
} }
} }
impl<'tcx> RustcInternal<'tcx> for Layout { unsafe impl<'tcx> RustcInternal<'tcx> for Layout {
type T = rustc_target::abi::Layout<'tcx>; type T = rustc_target::abi::Layout<'tcx>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
tables.layouts[*self] tcx.lift(tables.layouts[*self]).unwrap()
} }
} }
impl<'tcx, T> RustcInternal<'tcx> for &T unsafe impl<'tcx, T> RustcInternal<'tcx> for &T
where where
T: RustcInternal<'tcx>, T: RustcInternal<'tcx>,
{ {
type T = T::T; type T = T::T;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
(*self).internal(tables) (*self).internal(tables, tcx)
} }
} }
impl<'tcx, T> RustcInternal<'tcx> for Option<T> unsafe impl<'tcx, T> RustcInternal<'tcx> for Option<T>
where where
T: RustcInternal<'tcx>, T: RustcInternal<'tcx>,
{ {
type T = Option<T::T>; type T = Option<T::T>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
self.as_ref().map(|inner| inner.internal(tables)) self.as_ref().map(|inner| inner.internal(tables, tcx))
} }
} }
impl<'tcx, T> RustcInternal<'tcx> for Vec<T> unsafe impl<'tcx, T> RustcInternal<'tcx> for Vec<T>
where where
T: RustcInternal<'tcx>, T: RustcInternal<'tcx>,
{ {
type T = Vec<T::T>; type T = Vec<T::T>;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T { fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T {
self.iter().map(|e| e.internal(tables)).collect() self.iter().map(|e| e.internal(tables, tcx)).collect()
}
}
fn lift_unevaluated<'tcx>(
tcx: TyCtxt<'tcx>,
uneval: rustc_middle::mir::UnevaluatedConst<'tcx>,
) -> rustc_middle::mir::UnevaluatedConst<'tcx> {
rustc_middle::mir::UnevaluatedConst {
def: uneval.def,
args: tcx.lift(uneval.args).unwrap(),
promoted: uneval.promoted,
} }
} }

39
compiler/rustc_smir/src/rustc_internal/mod.rs
View File

@ -24,12 +24,38 @@ use std::ops::Index;
mod internal; mod internal;
pub mod pretty; pub mod pretty;
/// Convert an internal Rust compiler item into its stable counterpart, if one exists.
///
/// # Warning
///
/// This function is unstable, and its behavior may change at any point.
/// E.g.: Items that were previously supported, may no longer be supported, or its translation may
/// change.
///
/// # Panics
///
/// This function will panic if StableMIR has not been properly initialized.
pub fn stable<'tcx, S: Stable<'tcx>>(item: S) -> S::T { pub fn stable<'tcx, S: Stable<'tcx>>(item: S) -> S::T {
with_tables(|tables| item.stable(tables)) with_tables(|tables| item.stable(tables))
} }
pub fn internal<'tcx, S: RustcInternal<'tcx>>(item: S) -> S::T { /// Convert a stable item into its internal Rust compiler counterpart, if one exists.
with_tables(|tables| item.internal(tables)) ///
/// # Warning
///
/// This function is unstable, and it's behavior may change at any point.
/// Not every stable item can be converted to an internal one.
/// Furthermore, items that were previously supported, may no longer be supported in newer versions.
///
/// # Panics
///
/// This function will panic if StableMIR has not been properly initialized.
pub fn internal<'tcx, S>(tcx: TyCtxt<'tcx>, item: S) -> S::T
where
S: RustcInternal<'tcx>,
{
// The tcx argument ensures that the item won't outlive the type context.
with_tables(|tables| item.internal(tables, tcx))
} }
impl<'tcx> Index<stable_mir::DefId> for Tables<'tcx> { impl<'tcx> Index<stable_mir::DefId> for Tables<'tcx> {
@ -393,7 +419,12 @@ impl<K: PartialEq + Hash + Eq, V: Copy + Debug + PartialEq + IndexedVal> Index<V
/// Trait used to translate a stable construct to its rustc counterpart. /// Trait used to translate a stable construct to its rustc counterpart.
/// ///
/// This is basically a mirror of [crate::rustc_smir::Stable]. /// This is basically a mirror of [crate::rustc_smir::Stable].
pub trait RustcInternal<'tcx> { ///
/// # Safety
///
/// This trait is unsafe, and every implementation should ensure that their translation
/// is lifted if necessary with the given type context (`tcx`).
pub unsafe trait RustcInternal<'tcx> {
type T; type T;
fn internal(&self, tables: &mut Tables<'tcx>) -> Self::T; fn internal(&self, tables: &mut Tables<'tcx>, tcx: TyCtxt<'tcx>) -> Self::T;
} }

3
compiler/rustc_smir/src/rustc_smir/alloc.rs
View File

@ -27,7 +27,8 @@ pub fn new_allocation<'tcx>(
const_value: ConstValue<'tcx>, const_value: ConstValue<'tcx>,
tables: &mut Tables<'tcx>, tables: &mut Tables<'tcx>,
) -> Allocation { ) -> Allocation {
try_new_allocation(ty, const_value, tables).unwrap() try_new_allocation(ty, const_value, tables)
.expect(&format!("Failed to convert: {const_value:?} to {ty:?}"))
} }
#[allow(rustc::usage_of_qualified_ty)] #[allow(rustc::usage_of_qualified_ty)]

117
compiler/rustc_smir/src/rustc_smir/context.rs
View File

@ -29,7 +29,7 @@ use stable_mir::{Crate, CrateItem, CrateNum, DefId, Error, Filename, ItemKind, S
use std::cell::RefCell; use std::cell::RefCell;
use std::iter; use std::iter;
use crate::rustc_internal::{internal, RustcInternal}; use crate::rustc_internal::RustcInternal;
use crate::rustc_smir::builder::BodyBuilder; use crate::rustc_smir::builder::BodyBuilder;
use crate::rustc_smir::{alloc, new_item_kind, smir_crate, Stable, Tables}; use crate::rustc_smir::{alloc, new_item_kind, smir_crate, Stable, Tables};
@ -74,9 +74,8 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
fn trait_decls(&self, crate_num: CrateNum) -> stable_mir::TraitDecls { fn trait_decls(&self, crate_num: CrateNum) -> stable_mir::TraitDecls {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
tables let tcx = tables.tcx;
.tcx tcx.traits(crate_num.internal(&mut *tables, tcx))
.traits(crate_num.internal(&mut *tables))
.iter() .iter()
.map(|trait_def_id| tables.trait_def(*trait_def_id)) .map(|trait_def_id| tables.trait_def(*trait_def_id))
.collect() .collect()
@ -101,9 +100,8 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
fn trait_impls(&self, crate_num: CrateNum) -> stable_mir::ImplTraitDecls { fn trait_impls(&self, crate_num: CrateNum) -> stable_mir::ImplTraitDecls {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
tables let tcx = tables.tcx;
.tcx tcx.trait_impls_in_crate(crate_num.internal(&mut *tables, tcx))
.trait_impls_in_crate(crate_num.internal(&mut *tables))
.iter() .iter()
.map(|impl_def_id| tables.impl_def(*impl_def_id)) .map(|impl_def_id| tables.impl_def(*impl_def_id))
.collect() .collect()
@ -229,57 +227,68 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
fn adt_kind(&self, def: AdtDef) -> AdtKind { fn adt_kind(&self, def: AdtDef) -> AdtKind {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
def.internal(&mut *tables).adt_kind().stable(&mut *tables) let tcx = tables.tcx;
def.internal(&mut *tables, tcx).adt_kind().stable(&mut *tables)
} }
fn adt_is_box(&self, def: AdtDef) -> bool { fn adt_is_box(&self, def: AdtDef) -> bool {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
def.internal(&mut *tables).is_box() let tcx = tables.tcx;
def.internal(&mut *tables, tcx).is_box()
} }
fn adt_is_simd(&self, def: AdtDef) -> bool { fn adt_is_simd(&self, def: AdtDef) -> bool {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
def.internal(&mut *tables).repr().simd() let tcx = tables.tcx;
def.internal(&mut *tables, tcx).repr().simd()
} }
fn adt_is_cstr(&self, def: AdtDef) -> bool { fn adt_is_cstr(&self, def: AdtDef) -> bool {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let def_id = def.0.internal(&mut *tables); let tcx = tables.tcx;
let def_id = def.0.internal(&mut *tables, tcx);
tables.tcx.lang_items().c_str() == Some(def_id) tables.tcx.lang_items().c_str() == Some(def_id)
} }
fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig { fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let def_id = def.0.internal(&mut *tables); let tcx = tables.tcx;
let sig = tables.tcx.fn_sig(def_id).instantiate(tables.tcx, args.internal(&mut *tables)); let def_id = def.0.internal(&mut *tables, tcx);
let sig =
tables.tcx.fn_sig(def_id).instantiate(tables.tcx, args.internal(&mut *tables, tcx));
sig.stable(&mut *tables) sig.stable(&mut *tables)
} }
fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig { fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let args_ref = args.internal(&mut *tables); let tcx = tables.tcx;
let args_ref = args.internal(&mut *tables, tcx);
let sig = args_ref.as_closure().sig(); let sig = args_ref.as_closure().sig();
sig.stable(&mut *tables) sig.stable(&mut *tables)
} }
fn adt_variants_len(&self, def: AdtDef) -> usize { fn adt_variants_len(&self, def: AdtDef) -> usize {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
def.internal(&mut *tables).variants().len() let tcx = tables.tcx;
def.internal(&mut *tables, tcx).variants().len()
} }
fn variant_name(&self, def: VariantDef) -> Symbol { fn variant_name(&self, def: VariantDef) -> Symbol {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
def.internal(&mut *tables).name.to_string() let tcx = tables.tcx;
def.internal(&mut *tables, tcx).name.to_string()
} }
fn variant_fields(&self, def: VariantDef) -> Vec<FieldDef> { fn variant_fields(&self, def: VariantDef) -> Vec<FieldDef> {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
def.internal(&mut *tables).fields.iter().map(|f| f.stable(&mut *tables)).collect() let tcx = tables.tcx;
def.internal(&mut *tables, tcx).fields.iter().map(|f| f.stable(&mut *tables)).collect()
} }
fn eval_target_usize(&self, cnst: &Const) -> Result<u64, Error> { fn eval_target_usize(&self, cnst: &Const) -> Result<u64, Error> {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let mir_const = cnst.internal(&mut *tables); let tcx = tables.tcx;
let mir_const = cnst.internal(&mut *tables, tcx);
mir_const mir_const
.try_eval_target_usize(tables.tcx, ParamEnv::empty()) .try_eval_target_usize(tables.tcx, ParamEnv::empty())
.ok_or_else(|| Error::new(format!("Const `{cnst:?}` cannot be encoded as u64"))) .ok_or_else(|| Error::new(format!("Const `{cnst:?}` cannot be encoded as u64")))
@ -299,30 +308,36 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
fn new_rigid_ty(&self, kind: RigidTy) -> stable_mir::ty::Ty { fn new_rigid_ty(&self, kind: RigidTy) -> stable_mir::ty::Ty {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let internal_kind = kind.internal(&mut *tables); let tcx = tables.tcx;
let internal_kind = kind.internal(&mut *tables, tcx);
tables.tcx.mk_ty_from_kind(internal_kind).stable(&mut *tables) tables.tcx.mk_ty_from_kind(internal_kind).stable(&mut *tables)
} }
fn new_box_ty(&self, ty: stable_mir::ty::Ty) -> stable_mir::ty::Ty { fn new_box_ty(&self, ty: stable_mir::ty::Ty) -> stable_mir::ty::Ty {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let inner = ty.internal(&mut *tables); let tcx = tables.tcx;
let inner = ty.internal(&mut *tables, tcx);
ty::Ty::new_box(tables.tcx, inner).stable(&mut *tables) ty::Ty::new_box(tables.tcx, inner).stable(&mut *tables)
} }
fn def_ty(&self, item: stable_mir::DefId) -> stable_mir::ty::Ty { fn def_ty(&self, item: stable_mir::DefId) -> stable_mir::ty::Ty {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
tables.tcx.type_of(item.internal(&mut *tables)).instantiate_identity().stable(&mut *tables) let tcx = tables.tcx;
tcx.type_of(item.internal(&mut *tables, tcx)).instantiate_identity().stable(&mut *tables)
} }
fn def_ty_with_args(&self, item: stable_mir::DefId, args: &GenericArgs) -> stable_mir::ty::Ty { fn def_ty_with_args(&self, item: stable_mir::DefId, args: &GenericArgs) -> stable_mir::ty::Ty {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let args = args.internal(&mut *tables); let tcx = tables.tcx;
let def_ty = tables.tcx.type_of(item.internal(&mut *tables)); let args = args.internal(&mut *tables, tcx);
let def_ty = tables.tcx.type_of(item.internal(&mut *tables, tcx));
def_ty.instantiate(tables.tcx, args).stable(&mut *tables) def_ty.instantiate(tables.tcx, args).stable(&mut *tables)
} }
fn const_literal(&self, cnst: &stable_mir::ty::Const) -> String { fn const_literal(&self, cnst: &stable_mir::ty::Const) -> String {
internal(cnst).to_string() let mut tables = self.0.borrow_mut();
let tcx = tables.tcx;
cnst.internal(&mut *tables, tcx).to_string()
} }
fn span_of_an_item(&self, def_id: stable_mir::DefId) -> Span { fn span_of_an_item(&self, def_id: stable_mir::DefId) -> Span {
@ -337,7 +352,8 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> stable_mir::ty::Ty { fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> stable_mir::ty::Ty {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let internal_kind = ty.internal(&mut *tables); let tcx = tables.tcx;
let internal_kind = ty.internal(&mut *tables, tcx);
let internal_ty = tables.tcx.mk_ty_from_kind(internal_kind); let internal_ty = tables.tcx.mk_ty_from_kind(internal_kind);
internal_ty.discriminant_ty(tables.tcx).stable(&mut *tables) internal_ty.discriminant_ty(tables.tcx).stable(&mut *tables)
} }
@ -407,8 +423,9 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
args: &stable_mir::ty::GenericArgs, args: &stable_mir::ty::GenericArgs,
) -> Option<stable_mir::mir::mono::Instance> { ) -> Option<stable_mir::mir::mono::Instance> {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let def_id = def.0.internal(&mut *tables); let tcx = tables.tcx;
let args_ref = args.internal(&mut *tables); let def_id = def.0.internal(&mut *tables, tcx);
let args_ref = args.internal(&mut *tables, tcx);
match Instance::resolve(tables.tcx, ParamEnv::reveal_all(), def_id, args_ref) { match Instance::resolve(tables.tcx, ParamEnv::reveal_all(), def_id, args_ref) {
Ok(Some(instance)) => Some(instance.stable(&mut *tables)), Ok(Some(instance)) => Some(instance.stable(&mut *tables)),
Ok(None) | Err(_) => None, Ok(None) | Err(_) => None,
@ -417,7 +434,8 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
fn resolve_drop_in_place(&self, ty: stable_mir::ty::Ty) -> stable_mir::mir::mono::Instance { fn resolve_drop_in_place(&self, ty: stable_mir::ty::Ty) -> stable_mir::mir::mono::Instance {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let internal_ty = ty.internal(&mut *tables); let tcx = tables.tcx;
let internal_ty = ty.internal(&mut *tables, tcx);
let instance = Instance::resolve_drop_in_place(tables.tcx, internal_ty); let instance = Instance::resolve_drop_in_place(tables.tcx, internal_ty);
instance.stable(&mut *tables) instance.stable(&mut *tables)
} }
@ -428,8 +446,9 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
args: &GenericArgs, args: &GenericArgs,
) -> Option<stable_mir::mir::mono::Instance> { ) -> Option<stable_mir::mir::mono::Instance> {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let def_id = def.0.internal(&mut *tables); let tcx = tables.tcx;
let args_ref = args.internal(&mut *tables); let def_id = def.0.internal(&mut *tables, tcx);
let args_ref = args.internal(&mut *tables, tcx);
Instance::resolve_for_fn_ptr(tables.tcx, ParamEnv::reveal_all(), def_id, args_ref) Instance::resolve_for_fn_ptr(tables.tcx, ParamEnv::reveal_all(), def_id, args_ref)
.stable(&mut *tables) .stable(&mut *tables)
} }
@ -441,36 +460,44 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
kind: ClosureKind, kind: ClosureKind,
) -> Option<stable_mir::mir::mono::Instance> { ) -> Option<stable_mir::mir::mono::Instance> {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let def_id = def.0.internal(&mut *tables); let tcx = tables.tcx;
let args_ref = args.internal(&mut *tables); let def_id = def.0.internal(&mut *tables, tcx);
let closure_kind = kind.internal(&mut *tables); let args_ref = args.internal(&mut *tables, tcx);
let closure_kind = kind.internal(&mut *tables, tcx);
Instance::resolve_closure(tables.tcx, def_id, args_ref, closure_kind).stable(&mut *tables) Instance::resolve_closure(tables.tcx, def_id, args_ref, closure_kind).stable(&mut *tables)
} }
fn eval_instance(&self, def: InstanceDef, const_ty: Ty) -> Result<Allocation, Error> { fn eval_instance(&self, def: InstanceDef, const_ty: Ty) -> Result<Allocation, Error> {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let instance = tables.instances[def]; let instance = tables.instances[def];
let result = tables.tcx.const_eval_instance( let tcx = tables.tcx;
let result = tcx.const_eval_instance(
ParamEnv::reveal_all(), ParamEnv::reveal_all(),
instance, instance,
Some(tables.tcx.def_span(instance.def_id())), Some(tcx.def_span(instance.def_id())),
); );
result result
.map(|const_val| { .map(|const_val| {
alloc::try_new_allocation(const_ty.internal(&mut *tables), const_val, &mut *tables) alloc::try_new_allocation(
const_ty.internal(&mut *tables, tcx),
const_val,
&mut *tables,
)
}) })
.map_err(|e| e.stable(&mut *tables))? .map_err(|e| e.stable(&mut *tables))?
} }
fn eval_static_initializer(&self, def: StaticDef) -> Result<Allocation, Error> { fn eval_static_initializer(&self, def: StaticDef) -> Result<Allocation, Error> {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let def_id = def.0.internal(&mut *tables); let tcx = tables.tcx;
let def_id = def.0.internal(&mut *tables, tcx);
tables.tcx.eval_static_initializer(def_id).stable(&mut *tables) tables.tcx.eval_static_initializer(def_id).stable(&mut *tables)
} }
fn global_alloc(&self, alloc: stable_mir::mir::alloc::AllocId) -> GlobalAlloc { fn global_alloc(&self, alloc: stable_mir::mir::alloc::AllocId) -> GlobalAlloc {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let alloc_id = alloc.internal(&mut *tables); let tcx = tables.tcx;
let alloc_id = alloc.internal(&mut *tables, tcx);
tables.tcx.global_alloc(alloc_id).stable(&mut *tables) tables.tcx.global_alloc(alloc_id).stable(&mut *tables)
} }
@ -480,9 +507,11 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
) -> Option<stable_mir::mir::alloc::AllocId> { ) -> Option<stable_mir::mir::alloc::AllocId> {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let GlobalAlloc::VTable(ty, trait_ref) = global_alloc else { return None }; let GlobalAlloc::VTable(ty, trait_ref) = global_alloc else { return None };
let alloc_id = tables let tcx = tables.tcx;
.tcx let alloc_id = tables.tcx.vtable_allocation((
.vtable_allocation((ty.internal(&mut *tables), trait_ref.internal(&mut *tables))); ty.internal(&mut *tables, tcx),
trait_ref.internal(&mut *tables, tcx),
));
Some(alloc_id.stable(&mut *tables)) Some(alloc_id.stable(&mut *tables))
} }
@ -510,14 +539,16 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
fn ty_layout(&self, ty: Ty) -> Result<Layout, Error> { fn ty_layout(&self, ty: Ty) -> Result<Layout, Error> {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
let ty = ty.internal(&mut *tables); let tcx = tables.tcx;
let ty = ty.internal(&mut *tables, tcx);
let layout = tables.layout_of(ty)?.layout; let layout = tables.layout_of(ty)?.layout;
Ok(layout.stable(&mut *tables)) Ok(layout.stable(&mut *tables))
} }
fn layout_shape(&self, id: Layout) -> LayoutShape { fn layout_shape(&self, id: Layout) -> LayoutShape {
let mut tables = self.0.borrow_mut(); let mut tables = self.0.borrow_mut();
id.internal(&mut *tables).0.stable(&mut *tables) let tcx = tables.tcx;
id.internal(&mut *tables, tcx).0.stable(&mut *tables)
} }
} }

4
tests/ui-fulldeps/stable-mir/smir_internal.rs
View File

@ -26,11 +26,11 @@ use std::ops::ControlFlow;
const CRATE_NAME: &str = "input"; const CRATE_NAME: &str = "input";
fn test_translation(_tcx: TyCtxt) -> ControlFlow<()> { fn test_translation(tcx: TyCtxt<'_>) -> ControlFlow<()> {
let main_fn = stable_mir::entry_fn().unwrap(); let main_fn = stable_mir::entry_fn().unwrap();
let body = main_fn.body(); let body = main_fn.body();
let orig_ty = body.locals()[0].ty; let orig_ty = body.locals()[0].ty;
let rustc_ty = rustc_internal::internal(&orig_ty); let rustc_ty = rustc_internal::internal(tcx, &orig_ty);
assert!(rustc_ty.is_unit()); assert!(rustc_ty.is_unit());
ControlFlow::Continue(()) ControlFlow::Continue(())
} }