From 5151cd9d0142a8203f1e4495a66cc1a7a638637c Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 5 May 2025 15:07:04 +0800 Subject: [PATCH 01/22] refactor: add `Tables<'tcx, B: Bridge>` and `SmirContainer` --- compiler/rustc_smir/src/rustc_internal/mod.rs | 157 +++--------------- compiler/rustc_smir/src/rustc_smir/mod.rs | 83 ++++++--- 2 files changed, 87 insertions(+), 153 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs index 2982a920b03d1..871a6524f392b 100644 --- a/compiler/rustc_smir/src/rustc_internal/mod.rs +++ b/compiler/rustc_smir/src/rustc_internal/mod.rs @@ -17,12 +17,12 @@ use rustc_span::Span; use rustc_span::def_id::{CrateNum, DefId}; use scoped_tls::scoped_thread_local; use stable_mir::Error; -use stable_mir::abi::Layout; use stable_mir::compiler_interface::SmirInterface; use stable_mir::ty::IndexedVal; use crate::rustc_smir::context::SmirCtxt; use crate::rustc_smir::{Stable, Tables}; +use crate::rustc_smir::{Bridge, SmirContainer, Tables}; use crate::stable_mir; mod internal; @@ -40,7 +40,7 @@ pub mod pretty; /// /// This function will panic if StableMIR has not been properly initialized. pub fn stable<'tcx, S: Stable<'tcx>>(item: S) -> S::T { - with_tables(|tables| item.stable(tables)) + with_container(|tables, cx| item.stable(tables, cx)) } /// Convert a stable item into its internal Rust compiler counterpart, if one exists. @@ -54,137 +54,40 @@ 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>(tcx: TyCtxt<'tcx>, item: S) -> S::T<'tcx> +pub fn internal<'tcx, S>(item: S) -> S::T<'tcx> where S: RustcInternal, { - // The tcx argument ensures that the item won't outlive the type context. - with_tables(|tables| item.internal(tables, tcx)) + with_container(|tables, cx| item.internal(tables, cx)) } -impl<'tcx> Index for Tables<'tcx> { +impl<'tcx, B: Bridge> Index for Tables<'tcx, B> { type Output = DefId; #[inline(always)] - fn index(&self, index: stable_mir::DefId) -> &Self::Output { + fn index(&self, index: B::DefId) -> &Self::Output { &self.def_ids[index] } } -impl<'tcx> Index for Tables<'tcx> { - type Output = Span; - - #[inline(always)] - fn index(&self, index: stable_mir::ty::Span) -> &Self::Output { - &self.spans[index] - } -} - -impl<'tcx> Tables<'tcx> { - pub fn crate_item(&mut self, did: DefId) -> stable_mir::CrateItem { - stable_mir::CrateItem(self.create_def_id(did)) - } - - pub fn adt_def(&mut self, did: DefId) -> stable_mir::ty::AdtDef { - stable_mir::ty::AdtDef(self.create_def_id(did)) - } - - pub fn foreign_module_def(&mut self, did: DefId) -> stable_mir::ty::ForeignModuleDef { - stable_mir::ty::ForeignModuleDef(self.create_def_id(did)) - } - - pub fn foreign_def(&mut self, did: DefId) -> stable_mir::ty::ForeignDef { - stable_mir::ty::ForeignDef(self.create_def_id(did)) - } - - pub fn fn_def(&mut self, did: DefId) -> stable_mir::ty::FnDef { - stable_mir::ty::FnDef(self.create_def_id(did)) - } - - pub fn closure_def(&mut self, did: DefId) -> stable_mir::ty::ClosureDef { - stable_mir::ty::ClosureDef(self.create_def_id(did)) - } - - pub fn coroutine_def(&mut self, did: DefId) -> stable_mir::ty::CoroutineDef { - stable_mir::ty::CoroutineDef(self.create_def_id(did)) - } - - pub fn coroutine_closure_def(&mut self, did: DefId) -> stable_mir::ty::CoroutineClosureDef { - stable_mir::ty::CoroutineClosureDef(self.create_def_id(did)) - } - - pub fn alias_def(&mut self, did: DefId) -> stable_mir::ty::AliasDef { - stable_mir::ty::AliasDef(self.create_def_id(did)) - } - - pub fn param_def(&mut self, did: DefId) -> stable_mir::ty::ParamDef { - stable_mir::ty::ParamDef(self.create_def_id(did)) - } - - pub fn br_named_def(&mut self, did: DefId) -> stable_mir::ty::BrNamedDef { - stable_mir::ty::BrNamedDef(self.create_def_id(did)) - } - - pub fn trait_def(&mut self, did: DefId) -> stable_mir::ty::TraitDef { - stable_mir::ty::TraitDef(self.create_def_id(did)) - } - - pub fn generic_def(&mut self, did: DefId) -> stable_mir::ty::GenericDef { - stable_mir::ty::GenericDef(self.create_def_id(did)) - } - - pub fn const_def(&mut self, did: DefId) -> stable_mir::ty::ConstDef { - stable_mir::ty::ConstDef(self.create_def_id(did)) - } - - pub fn impl_def(&mut self, did: DefId) -> stable_mir::ty::ImplDef { - stable_mir::ty::ImplDef(self.create_def_id(did)) - } - - pub fn region_def(&mut self, did: DefId) -> stable_mir::ty::RegionDef { - stable_mir::ty::RegionDef(self.create_def_id(did)) - } - - pub fn coroutine_witness_def(&mut self, did: DefId) -> stable_mir::ty::CoroutineWitnessDef { - stable_mir::ty::CoroutineWitnessDef(self.create_def_id(did)) - } - - pub fn assoc_def(&mut self, did: DefId) -> stable_mir::ty::AssocDef { - stable_mir::ty::AssocDef(self.create_def_id(did)) - } - - pub fn opaque_def(&mut self, did: DefId) -> stable_mir::ty::OpaqueDef { - stable_mir::ty::OpaqueDef(self.create_def_id(did)) - } - - pub fn prov(&mut self, aid: AllocId) -> stable_mir::ty::Prov { - stable_mir::ty::Prov(self.create_alloc_id(aid)) - } - - pub(crate) fn create_def_id(&mut self, did: DefId) -> stable_mir::DefId { +impl<'tcx, B: Bridge> Tables<'tcx, B> { + pub fn create_def_id(&mut self, did: DefId) -> B::DefId { self.def_ids.create_or_fetch(did) } - pub(crate) fn create_alloc_id(&mut self, aid: AllocId) -> stable_mir::mir::alloc::AllocId { + pub fn create_alloc_id(&mut self, aid: AllocId) -> B::AllocId { self.alloc_ids.create_or_fetch(aid) } - pub(crate) fn create_span(&mut self, span: Span) -> stable_mir::ty::Span { + pub fn create_span(&mut self, span: Span) -> B::Span { self.spans.create_or_fetch(span) } - pub(crate) fn instance_def( - &mut self, - instance: ty::Instance<'tcx>, - ) -> stable_mir::mir::mono::InstanceDef { + pub fn instance_def(&mut self, instance: ty::Instance<'tcx>) -> B::InstanceDef { self.instances.create_or_fetch(instance) } - pub(crate) fn static_def(&mut self, did: DefId) -> stable_mir::mir::mono::StaticDef { - stable_mir::mir::mono::StaticDef(self.create_def_id(did)) - } - - pub(crate) fn layout_id(&mut self, layout: rustc_abi::Layout<'tcx>) -> Layout { + pub fn layout_id(&mut self, layout: rustc_abi::Layout<'tcx>) -> B::Layout { self.layouts.create_or_fetch(layout) } } @@ -197,25 +100,28 @@ pub fn crate_num(item: &stable_mir::Crate) -> CrateNum { // datastructures and stable MIR datastructures scoped_thread_local! (static TLV: Cell<*const ()>); -pub(crate) fn init<'tcx, F, T>(cx: &SmirCtxt<'tcx>, f: F) -> T +pub(crate) fn init<'tcx, F, T, B: Bridge>(container: &SmirContainer<'tcx, B>, f: F) -> T where F: FnOnce() -> T, { assert!(!TLV.is_set()); - let ptr = cx as *const _ as *const (); + let ptr = container as *const _ as *const (); TLV.set(&Cell::new(ptr), || f()) } /// Loads the current context and calls a function with it. /// Do not nest these, as that will ICE. -pub(crate) fn with_tables(f: impl for<'tcx> FnOnce(&mut Tables<'tcx>) -> R) -> R { +pub(crate) fn with_container<'tcx, R, B: Bridge>( + f: impl 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 context = ptr as *const SmirCtxt<'_>; - let mut tables = unsafe { (*context).0.borrow_mut() }; - f(&mut *tables) + let container = ptr as *const SmirContainer<'tcx, B>; + let mut tables = unsafe { (*container).tables.borrow_mut() }; + let cx = unsafe { (*container).cx.borrow() }; + f(&mut *tables, &*cx) }) } @@ -223,23 +129,10 @@ pub fn run(tcx: TyCtxt<'_>, f: F) -> Result where F: FnOnce() -> T, { - let tables = SmirCtxt(RefCell::new(Tables { - tcx, - def_ids: IndexMap::default(), - alloc_ids: IndexMap::default(), - spans: IndexMap::default(), - types: IndexMap::default(), - instances: IndexMap::default(), - ty_consts: IndexMap::default(), - mir_consts: IndexMap::default(), - layouts: IndexMap::default(), - })); - - let interface = SmirInterface { cx: tables }; - - // Pass the `SmirInterface` to compiler_interface::run - // and initialize the rustc-specific TLS with tables. - stable_mir::compiler_interface::run(&interface, || init(&interface.cx, f)) + let smir_cx = RefCell::new(SmirCtxt::new(tcx)); + let container = SmirContainer { tables: RefCell::new(Tables::new(tcx)), cx: smir_cx }; + + stable_mir::compiler_interface::run(&container, || init(&container, f)) } /// Instantiate and run the compiler with the provided arguments and callback. diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs index 64fe181c26d48..5a3e82b03f99e 100644 --- a/compiler/rustc_smir/src/rustc_smir/mod.rs +++ b/compiler/rustc_smir/src/rustc_smir/mod.rs @@ -8,16 +8,16 @@ //! For now, we are developing everything inside `rustc`, thus, we keep this module private. use std::ops::RangeInclusive; +use std::cell::RefCell; +use std::fmt::Debug; +use context::SmirCtxt; use rustc_data_structures::PointeeSized; 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_span::def_id::{CrateNum, DefId, LOCAL_CRATE}; -use stable_mir::abi::Layout; -use stable_mir::mir::mono::{InstanceDef, StaticDef}; -use stable_mir::ty::{FnDef, MirConstId, Span, TyConstId}; use stable_mir::{CtorKind, ItemKind}; use tracing::debug; @@ -29,28 +29,50 @@ mod builder; pub mod context; mod convert; -pub struct Tables<'tcx> { - pub(crate) tcx: TyCtxt<'tcx>, - pub(crate) def_ids: IndexMap, - pub(crate) alloc_ids: IndexMap, - pub(crate) spans: IndexMap, - pub(crate) types: IndexMap, stable_mir::ty::Ty>, - pub(crate) instances: IndexMap, InstanceDef>, - pub(crate) ty_consts: IndexMap, TyConstId>, - pub(crate) mir_consts: IndexMap, MirConstId>, - pub(crate) layouts: IndexMap, Layout>, +/// A container which is used for TLS. +pub struct SmirContainer<'tcx, B: Bridge> { + pub tables: RefCell>, + pub cx: RefCell>, } -impl<'tcx> Tables<'tcx> { - pub(crate) fn intern_ty(&mut self, ty: Ty<'tcx>) -> stable_mir::ty::Ty { +pub struct Tables<'tcx, B: Bridge> { + tcx: TyCtxt<'tcx>, + pub(crate) def_ids: IndexMap, + pub(crate) alloc_ids: IndexMap, + pub(crate) spans: IndexMap, + pub(crate) types: IndexMap, B::Ty>, + pub(crate) instances: IndexMap, B::InstanceDef>, + pub(crate) ty_consts: IndexMap, B::TyConstId>, + pub(crate) mir_consts: IndexMap, B::MirConstId>, + pub(crate) layouts: IndexMap, B::Layout>, +} + +impl<'tcx, B: Bridge> Tables<'tcx, B> { + pub(crate) fn new(tcx: TyCtxt<'tcx>) -> Self { + Self { + tcx, + def_ids: IndexMap::default(), + alloc_ids: IndexMap::default(), + spans: IndexMap::default(), + types: IndexMap::default(), + instances: IndexMap::default(), + ty_consts: IndexMap::default(), + mir_consts: IndexMap::default(), + layouts: IndexMap::default(), + } + } +} + +impl<'tcx, B: Bridge> Tables<'tcx, B> { + pub(crate) fn intern_ty(&mut self, ty: Ty<'tcx>) -> B::Ty { self.types.create_or_fetch(ty) } - pub(crate) fn intern_ty_const(&mut self, ct: ty::Const<'tcx>) -> TyConstId { + pub(crate) fn intern_ty_const(&mut self, ct: ty::Const<'tcx>) -> B::TyConstId { self.ty_consts.create_or_fetch(ct) } - pub(crate) fn intern_mir_const(&mut self, constant: mir::Const<'tcx>) -> MirConstId { + pub(crate) fn intern_mir_const(&mut self, constant: mir::Const<'tcx>) -> B::MirConstId { self.mir_consts.create_or_fetch(constant) } @@ -82,19 +104,38 @@ impl<'tcx> Tables<'tcx> { !must_override && self.tcx.is_mir_available(def_id) } - fn to_fn_def(&mut self, def_id: DefId) -> Option { + fn filter_fn_def(&mut self, def_id: DefId) -> Option { if matches!(self.tcx.def_kind(def_id), DefKind::Fn | DefKind::AssocFn) { - Some(self.fn_def(def_id)) + Some(def_id) } else { None } } - fn to_static(&mut self, def_id: DefId) -> Option { - matches!(self.tcx.def_kind(def_id), DefKind::Static { .. }).then(|| self.static_def(def_id)) + fn filter_static_def(&mut self, def_id: DefId) -> Option { + 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 +/// useful when programming in stable_mir-agnostic settings. +pub trait Bridge { + type DefId: Copy + Debug + PartialEq + IndexedVal; + type AllocId: Copy + Debug + PartialEq + IndexedVal; + type Span: Copy + Debug + PartialEq + IndexedVal; + type Ty: Copy + Debug + PartialEq + IndexedVal; + type InstanceDef: Copy + Debug + PartialEq + IndexedVal; + type TyConstId: Copy + Debug + PartialEq + IndexedVal; + type MirConstId: Copy + Debug + PartialEq + IndexedVal; + type Layout: Copy + Debug + PartialEq + IndexedVal; + type Error: SmirError; +} + +pub trait SmirError { + fn new(msg: String) -> Self; + fn from_internal(err: T) -> Self; +} + /// Iterate over the definitions of the given crate. pub(crate) fn filter_def_ids(tcx: TyCtxt<'_>, krate: CrateNum, mut func: F) -> Vec where From 303f01a882633a6766a67c90671d2ba0528265e6 Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 5 May 2025 15:15:15 +0800 Subject: [PATCH 02/22] refactor: make `SmirInterface` a trait and impl it for `SmirContainer` - rewrite all `SmirInterface` apis. - add `BridgeTys` to impl those associated types in `Bridge`. - move `**_def()` stuffs living in `impl Tables` from `rustc_internal` to `stable_mir`. --- compiler/rustc_smir/src/rustc_internal/mod.rs | 1 - compiler/rustc_smir/src/rustc_smir/mod.rs | 124 -- .../src/stable_mir/compiler_interface.rs | 1074 +++++++++++++---- compiler/rustc_smir/src/stable_mir/mod.rs | 38 + compiler/rustc_smir/src/stable_mir/ty.rs | 6 + 5 files changed, 912 insertions(+), 331 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs index 871a6524f392b..3434c9fbf928d 100644 --- a/compiler/rustc_smir/src/rustc_internal/mod.rs +++ b/compiler/rustc_smir/src/rustc_internal/mod.rs @@ -17,7 +17,6 @@ use rustc_span::Span; use rustc_span::def_id::{CrateNum, DefId}; use scoped_tls::scoped_thread_local; use stable_mir::Error; -use stable_mir::compiler_interface::SmirInterface; use stable_mir::ty::IndexedVal; use crate::rustc_smir::context::SmirCtxt; diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs index 5a3e82b03f99e..2f5a9ea9a1ec9 100644 --- a/compiler/rustc_smir/src/rustc_smir/mod.rs +++ b/compiler/rustc_smir/src/rustc_smir/mod.rs @@ -7,7 +7,6 @@ //! //! For now, we are developing everything inside `rustc`, thus, we keep this module private. -use std::ops::RangeInclusive; use std::cell::RefCell; use std::fmt::Debug; @@ -18,8 +17,6 @@ use rustc_middle::mir; use rustc_middle::mir::interpret::AllocId; use rustc_middle::ty::{self, Instance, Ty, TyCtxt}; use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE}; -use stable_mir::{CtorKind, ItemKind}; -use tracing::debug; use crate::rustc_internal::IndexMap; use crate::stable_mir; @@ -153,124 +150,3 @@ where .collect() } } - -/// Build a stable mir crate from a given crate number. -pub(crate) fn smir_crate(tcx: TyCtxt<'_>, crate_num: CrateNum) -> stable_mir::Crate { - let crate_name = tcx.crate_name(crate_num).to_string(); - let is_local = crate_num == LOCAL_CRATE; - debug!(?crate_name, ?crate_num, "smir_crate"); - stable_mir::Crate { id: crate_num.into(), name: crate_name, is_local } -} - -pub(crate) fn new_item_kind(kind: DefKind) -> ItemKind { - match kind { - DefKind::Mod - | DefKind::Struct - | DefKind::Union - | DefKind::Enum - | DefKind::Variant - | DefKind::Trait - | DefKind::TyAlias - | DefKind::ForeignTy - | DefKind::TraitAlias - | DefKind::AssocTy - | DefKind::TyParam - | DefKind::ConstParam - | DefKind::Macro(_) - | DefKind::ExternCrate - | DefKind::Use - | DefKind::ForeignMod - | DefKind::OpaqueTy - | DefKind::Field - | DefKind::LifetimeParam - | DefKind::Impl { .. } - | DefKind::GlobalAsm => { - unreachable!("Not a valid item kind: {kind:?}"); - } - DefKind::Closure | DefKind::AssocFn | DefKind::Fn | DefKind::SyntheticCoroutineBody => { - ItemKind::Fn - } - DefKind::Const | DefKind::InlineConst | DefKind::AssocConst | DefKind::AnonConst => { - ItemKind::Const - } - DefKind::Static { .. } => ItemKind::Static, - DefKind::Ctor(_, rustc_hir::def::CtorKind::Const) => ItemKind::Ctor(CtorKind::Const), - DefKind::Ctor(_, rustc_hir::def::CtorKind::Fn) => ItemKind::Ctor(CtorKind::Fn), - } -} - -/// Trait used to convert between an internal MIR type to a Stable MIR type. -pub trait Stable<'cx>: PointeeSized { - /// The stable representation of the type implementing Stable. - type T; - /// Converts an object to the equivalent Stable MIR representation. - fn stable(&self, tables: &mut Tables<'_>) -> Self::T; -} - -impl<'tcx, T> Stable<'tcx> for &T -where - T: Stable<'tcx>, -{ - type T = T::T; - - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - (*self).stable(tables) - } -} - -impl<'tcx, T> Stable<'tcx> for Option -where - T: Stable<'tcx>, -{ - type T = Option; - - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - self.as_ref().map(|value| value.stable(tables)) - } -} - -impl<'tcx, T, E> Stable<'tcx> for Result -where - T: Stable<'tcx>, - E: Stable<'tcx>, -{ - type T = Result; - - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - match self { - Ok(val) => Ok(val.stable(tables)), - Err(error) => Err(error.stable(tables)), - } - } -} - -impl<'tcx, T> Stable<'tcx> for &[T] -where - T: Stable<'tcx>, -{ - type T = Vec; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - self.iter().map(|e| e.stable(tables)).collect() - } -} - -impl<'tcx, T, U> Stable<'tcx> for (T, U) -where - T: Stable<'tcx>, - U: Stable<'tcx>, -{ - type T = (T::T, U::T); - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - (self.0.stable(tables), self.1.stable(tables)) - } -} - -impl<'tcx, T> Stable<'tcx> for RangeInclusive -where - T: Stable<'tcx>, -{ - type T = RangeInclusive; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - RangeInclusive::new(self.start().stable(tables), self.end().stable(tables)) - } -} diff --git a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs index 2668fba9f4f60..a3dd612b2f933 100644 --- a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs +++ b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs @@ -5,13 +5,14 @@ use std::cell::Cell; -use rustc_smir::context::SmirCtxt; +use rustc_hir::def::DefKind; +use rustc_smir::{Bridge, SmirContainer, Tables}; use stable_mir::abi::{FnAbi, Layout, LayoutShape, ReprOptions}; use stable_mir::crate_def::Attribute; use stable_mir::mir::alloc::{AllocId, GlobalAlloc}; use stable_mir::mir::mono::{Instance, InstanceDef, StaticDef}; use stable_mir::mir::{BinOp, Body, Place, UnOp}; -use stable_mir::target::MachineInfo; +use stable_mir::target::{MachineInfo, MachineSize}; use stable_mir::ty::{ AdtDef, AdtKind, Allocation, ClosureDef, ClosureKind, CoroutineDef, Discr, FieldDef, FnDef, ForeignDef, ForeignItemKind, ForeignModule, ForeignModuleDef, GenericArgs, GenericPredicates, @@ -19,119 +20,571 @@ use stable_mir::ty::{ TraitDecl, TraitDef, Ty, TyConst, TyConstId, TyKind, UintTy, VariantDef, VariantIdx, }; use stable_mir::{ - AssocItems, Crate, CrateItem, CrateItems, CrateNum, DefId, Error, Filename, ImplTraitDecls, - ItemKind, Symbol, TraitDecls, mir, + AssocItems, Crate, CrateDef, CrateItem, CrateItems, CrateNum, DefId, Error, Filename, + ImplTraitDecls, ItemKind, Symbol, TraitDecls, alloc, mir, new_item_kind, }; +use tracing::debug; use crate::{rustc_smir, stable_mir}; -/// Stable public API for querying compiler information. -/// -/// All queries are delegated to an internal [`SmirCtxt`] that provides -/// similar APIs but based on internal rustc constructs. -/// -/// Do not use this directly. This is currently used in the macro expansion. -pub(crate) struct SmirInterface<'tcx> { - pub(crate) cx: SmirCtxt<'tcx>, +pub struct BridgeTys; + +impl Bridge for BridgeTys { + type DefId = stable_mir::DefId; + type AllocId = stable_mir::mir::alloc::AllocId; + type Span = stable_mir::ty::Span; + type Ty = stable_mir::ty::Ty; + type InstanceDef = stable_mir::mir::mono::InstanceDef; + type TyConstId = stable_mir::ty::TyConstId; + type MirConstId = stable_mir::ty::MirConstId; + type Layout = stable_mir::abi::Layout; + type Error = stable_mir::Error; } -impl<'tcx> SmirInterface<'tcx> { - pub(crate) fn entry_fn(&self) -> Option { - self.cx.entry_fn() +impl<'tcx> Tables<'tcx, BridgeTys> { + pub(crate) fn crate_item(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::CrateItem { + stable_mir::CrateItem(self.create_def_id(did)) } - /// Retrieve all items of the local crate that have a MIR associated with them. - pub(crate) fn all_local_items(&self) -> CrateItems { - self.cx.all_local_items() + pub(crate) fn adt_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::AdtDef { + stable_mir::ty::AdtDef(self.create_def_id(did)) } - /// Retrieve the body of a function. - /// This function will panic if the body is not available. - pub(crate) fn mir_body(&self, item: DefId) -> mir::Body { - self.cx.mir_body(item) + pub(crate) fn foreign_module_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::ty::ForeignModuleDef { + stable_mir::ty::ForeignModuleDef(self.create_def_id(did)) } - /// Check whether the body of a function is available. - pub(crate) fn has_body(&self, item: DefId) -> bool { - self.cx.has_body(item) + pub(crate) fn foreign_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::ty::ForeignDef { + stable_mir::ty::ForeignDef(self.create_def_id(did)) } - pub(crate) fn foreign_modules(&self, crate_num: CrateNum) -> Vec { - self.cx.foreign_modules(crate_num) + pub(crate) fn fn_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::FnDef { + stable_mir::ty::FnDef(self.create_def_id(did)) } - /// Retrieve all functions defined in this crate. - pub(crate) fn crate_functions(&self, crate_num: CrateNum) -> Vec { - self.cx.crate_functions(crate_num) + pub(crate) fn closure_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::ty::ClosureDef { + stable_mir::ty::ClosureDef(self.create_def_id(did)) } - /// Retrieve all static items defined in this crate. - pub(crate) fn crate_statics(&self, crate_num: CrateNum) -> Vec { - self.cx.crate_statics(crate_num) + pub(crate) fn coroutine_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::ty::CoroutineDef { + stable_mir::ty::CoroutineDef(self.create_def_id(did)) + } + + pub(crate) fn coroutine_closure_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::ty::CoroutineClosureDef { + stable_mir::ty::CoroutineClosureDef(self.create_def_id(did)) + } + + pub(crate) fn alias_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::AliasDef { + stable_mir::ty::AliasDef(self.create_def_id(did)) + } + + pub(crate) fn param_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::ParamDef { + stable_mir::ty::ParamDef(self.create_def_id(did)) + } + + pub(crate) fn br_named_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::ty::BrNamedDef { + stable_mir::ty::BrNamedDef(self.create_def_id(did)) + } + + pub(crate) fn trait_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::TraitDef { + stable_mir::ty::TraitDef(self.create_def_id(did)) } - pub(crate) fn foreign_module(&self, mod_def: ForeignModuleDef) -> ForeignModule { - self.cx.foreign_module(mod_def) + pub(crate) fn generic_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::ty::GenericDef { + stable_mir::ty::GenericDef(self.create_def_id(did)) } - pub(crate) fn foreign_items(&self, mod_def: ForeignModuleDef) -> Vec { - self.cx.foreign_items(mod_def) + pub(crate) fn const_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::ConstDef { + stable_mir::ty::ConstDef(self.create_def_id(did)) } - pub(crate) fn all_trait_decls(&self) -> TraitDecls { - self.cx.all_trait_decls() + pub(crate) fn impl_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::ImplDef { + stable_mir::ty::ImplDef(self.create_def_id(did)) + } + + /* + pub(crate) fn region_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::ty::RegionDef { + stable_mir::ty::RegionDef(self.create_def_id(did)) + } + */ + + pub(crate) fn coroutine_witness_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::ty::CoroutineWitnessDef { + stable_mir::ty::CoroutineWitnessDef(self.create_def_id(did)) } - pub(crate) fn trait_decls(&self, crate_num: CrateNum) -> TraitDecls { - self.cx.trait_decls(crate_num) + pub(crate) fn assoc_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::AssocDef { + stable_mir::ty::AssocDef(self.create_def_id(did)) } - pub(crate) fn trait_decl(&self, trait_def: &TraitDef) -> TraitDecl { - self.cx.trait_decl(trait_def) + pub(crate) fn opaque_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::ty::OpaqueDef { + stable_mir::ty::OpaqueDef(self.create_def_id(did)) + } + + pub(crate) fn prov( + &mut self, + aid: rustc_middle::mir::interpret::AllocId, + ) -> stable_mir::ty::Prov { + stable_mir::ty::Prov(self.create_alloc_id(aid)) + } + + pub(crate) fn static_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> stable_mir::mir::mono::StaticDef { + stable_mir::mir::mono::StaticDef(self.create_def_id(did)) + } +} + +/// Stable public API for querying compiler information. +/// +/// All queries are delegated to [`crate::rustc_smir::context::SmirCtxt`] that provides +/// similar APIs but based on internal rustc constructs. +/// +/// Do not use this directly. This is currently used in the macro expansion. +pub(crate) trait SmirInterface { + fn entry_fn(&self) -> Option; + /// Retrieve all items of the local crate that have a MIR associated with them. + fn all_local_items(&self) -> CrateItems; + /// Retrieve the body of a function. + /// This function will panic if the body is not available. + fn mir_body(&self, item: DefId) -> mir::Body; + /// Check whether the body of a function is available. + fn has_body(&self, item: DefId) -> bool; + fn foreign_modules(&self, crate_num: CrateNum) -> Vec; + + /// Retrieve all functions defined in this crate. + fn crate_functions(&self, crate_num: CrateNum) -> Vec; + + /// Retrieve all static items defined in this crate. + fn crate_statics(&self, crate_num: CrateNum) -> Vec; + fn foreign_module(&self, mod_def: ForeignModuleDef) -> ForeignModule; + fn foreign_items(&self, mod_def: ForeignModuleDef) -> Vec; + fn all_trait_decls(&self) -> TraitDecls; + fn trait_decls(&self, crate_num: CrateNum) -> TraitDecls; + fn trait_decl(&self, trait_def: &TraitDef) -> TraitDecl; + fn all_trait_impls(&self) -> ImplTraitDecls; + fn trait_impls(&self, crate_num: CrateNum) -> ImplTraitDecls; + fn trait_impl(&self, trait_impl: &ImplDef) -> ImplTrait; + fn generics_of(&self, def_id: DefId) -> Generics; + fn predicates_of(&self, def_id: DefId) -> GenericPredicates; + fn explicit_predicates_of(&self, def_id: DefId) -> GenericPredicates; + + /// Get information about the local crate. + fn local_crate(&self) -> Crate; + /// Retrieve a list of all external crates. + fn external_crates(&self) -> Vec; + + /// Find a crate with the given name. + fn find_crates(&self, name: &str) -> Vec; + + /// Returns the name of given `DefId` + fn def_name(&self, def_id: DefId, trimmed: bool) -> Symbol; + + /// Return registered tool attributes with the given attribute name. + /// + /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool + /// attributes will simply return an empty list. + /// + /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`. + /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`. + fn tool_attrs(&self, def_id: DefId, attr: &[Symbol]) -> Vec; + + /// Get all tool attributes of a definition. + fn all_tool_attrs(&self, def_id: DefId) -> Vec; + + /// Returns printable, human readable form of `Span` + fn span_to_string(&self, span: Span) -> String; + + /// Return filename from given `Span`, for diagnostic purposes + fn get_filename(&self, span: &Span) -> Filename; + + /// Return lines corresponding to this `Span` + fn get_lines(&self, span: &Span) -> LineInfo; + + /// Returns the `kind` of given `DefId` + fn item_kind(&self, item: CrateItem) -> ItemKind; + + /// Returns whether this is a foreign item. + fn is_foreign_item(&self, item: DefId) -> bool; + + /// Returns the kind of a given foreign item. + fn foreign_item_kind(&self, def: ForeignDef) -> ForeignItemKind; + + /// Returns the kind of a given algebraic data type + fn adt_kind(&self, def: AdtDef) -> AdtKind; + + /// Returns if the ADT is a box. + fn adt_is_box(&self, def: AdtDef) -> bool; + + /// Returns whether this ADT is simd. + fn adt_is_simd(&self, def: AdtDef) -> bool; + + /// Returns whether this definition is a C string. + fn adt_is_cstr(&self, def: AdtDef) -> bool; + + /// Retrieve the function signature for the given generic arguments. + fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig; + + /// Retrieve the intrinsic definition if the item corresponds one. + fn intrinsic(&self, item: DefId) -> Option; + + /// Retrieve the plain function name of an intrinsic. + fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol; + + /// Retrieve the closure signature for the given generic arguments. + fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig; + + /// The number of variants in this ADT. + fn adt_variants_len(&self, def: AdtDef) -> usize; + + /// The name of a variant. + fn variant_name(&self, def: VariantDef) -> Symbol; + fn variant_fields(&self, def: VariantDef) -> Vec; + + /// Evaluate constant as a target usize. + fn eval_target_usize(&self, cnst: &MirConst) -> Result; + fn eval_target_usize_ty(&self, cnst: &TyConst) -> Result; + + /// Create a new zero-sized constant. + fn try_new_const_zst(&self, ty: Ty) -> Result; + + /// Create a new constant that represents the given string value. + fn new_const_str(&self, value: &str) -> MirConst; + + /// Create a new constant that represents the given boolean value. + fn new_const_bool(&self, value: bool) -> MirConst; + + /// Create a new constant that represents the given value. + fn try_new_const_uint(&self, value: u128, uint_ty: UintTy) -> Result; + fn try_new_ty_const_uint(&self, value: u128, uint_ty: UintTy) -> Result; + + /// Create a new type from the given kind. + fn new_rigid_ty(&self, kind: RigidTy) -> Ty; + + /// Create a new box type, `Box`, for the given inner type `T`. + fn new_box_ty(&self, ty: Ty) -> Ty; + + /// Returns the type of given crate item. + fn def_ty(&self, item: DefId) -> Ty; + + /// Returns the type of given definition instantiated with the given arguments. + fn def_ty_with_args(&self, item: DefId, args: &GenericArgs) -> Ty; + + /// Returns literal value of a const as a string. + fn mir_const_pretty(&self, cnst: &MirConst) -> String; + + /// `Span` of an item + fn span_of_an_item(&self, def_id: DefId) -> Span; + + fn ty_const_pretty(&self, ct: TyConstId) -> String; + + /// Obtain the representation of a type. + fn ty_pretty(&self, ty: Ty) -> String; + + /// Obtain the kind of a type. + fn ty_kind(&self, ty: Ty) -> TyKind; + + // Get the discriminant Ty for this Ty if there's one. + fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> Ty; + + /// Get the body of an Instance which is already monomorphized. + fn instance_body(&self, instance: InstanceDef) -> Option; + + /// Get the instance type with generic instantiations applied and lifetimes erased. + fn instance_ty(&self, instance: InstanceDef) -> Ty; + + /// Get the instantiation types. + fn instance_args(&self, def: InstanceDef) -> GenericArgs; + + /// Get the instance. + fn instance_def_id(&self, instance: InstanceDef) -> DefId; + + /// Get the instance mangled name. + fn instance_mangled_name(&self, instance: InstanceDef) -> Symbol; + + /// Check if this is an empty DropGlue shim. + fn is_empty_drop_shim(&self, def: InstanceDef) -> bool; + + /// Convert a non-generic crate item into an instance. + /// This function will panic if the item is generic. + fn mono_instance(&self, def_id: DefId) -> Instance; + + /// Item requires monomorphization. + fn requires_monomorphization(&self, def_id: DefId) -> bool; + + /// Resolve an instance from the given function definition and generic arguments. + fn resolve_instance(&self, def: FnDef, args: &GenericArgs) -> Option; + + /// Resolve an instance for drop_in_place for the given type. + fn resolve_drop_in_place(&self, ty: Ty) -> Instance; + + /// Resolve instance for a function pointer. + fn resolve_for_fn_ptr(&self, def: FnDef, args: &GenericArgs) -> Option; + + /// Resolve instance for a closure with the requested type. + fn resolve_closure( + &self, + def: ClosureDef, + args: &GenericArgs, + kind: ClosureKind, + ) -> Option; + + /// Evaluate a static's initializer. + fn eval_static_initializer(&self, def: StaticDef) -> Result; + + /// Try to evaluate an instance into a constant. + fn eval_instance(&self, def: InstanceDef, const_ty: Ty) -> Result; + + /// Retrieve global allocation for the given allocation ID. + fn global_alloc(&self, id: AllocId) -> GlobalAlloc; + + /// Retrieve the id for the virtual table. + fn vtable_allocation(&self, global_alloc: &GlobalAlloc) -> Option; + fn krate(&self, def_id: DefId) -> Crate; + fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol; + + /// Return information about the target machine. + fn target_info(&self) -> MachineInfo; + + /// Get an instance ABI. + fn instance_abi(&self, def: InstanceDef) -> Result; + + /// Get the ABI of a function pointer. + fn fn_ptr_abi(&self, fn_ptr: PolyFnSig) -> Result; + + /// Get the layout of a type. + fn ty_layout(&self, ty: Ty) -> Result; + + /// Get the layout shape. + fn layout_shape(&self, id: Layout) -> LayoutShape; + + /// Get a debug string representation of a place. + fn place_pretty(&self, place: &Place) -> String; + + /// Get the resulting type of binary operation. + fn binop_ty(&self, bin_op: BinOp, rhs: Ty, lhs: Ty) -> Ty; + + /// Get the resulting type of unary operation. + fn unop_ty(&self, un_op: UnOp, arg: Ty) -> Ty; + + /// Get all associated items of a definition. + fn associated_items(&self, def_id: DefId) -> AssocItems; +} + +impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { + fn entry_fn(&self) -> Option { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = cx.entry_fn(); + Some(tables.crate_item(did?)) } - pub(crate) fn all_trait_impls(&self) -> ImplTraitDecls { - self.cx.all_trait_impls() + /// Retrieve all items of the local crate that have a MIR associated with them. + fn all_local_items(&self) -> CrateItems { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.all_local_items().iter().map(|did| tables.crate_item(*did)).collect() } - pub(crate) fn trait_impls(&self, crate_num: CrateNum) -> ImplTraitDecls { - self.cx.trait_impls(crate_num) + /// Retrieve the body of a function. + /// This function will panic if the body is not available. + fn mir_body(&self, item: DefId) -> mir::Body { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[item]; + cx.mir_body(did).stable(&mut *tables, cx) } - pub(crate) fn trait_impl(&self, trait_impl: &ImplDef) -> ImplTrait { - self.cx.trait_impl(trait_impl) + /// Check whether the body of a function is available. + fn has_body(&self, item: DefId) -> bool { + let mut tables = self.tables.borrow_mut(); + let tables_ref = &mut *tables; + let cx = &*self.cx.borrow(); + let def = item.internal(tables_ref, cx); + cx.has_body(def, tables_ref) } - pub(crate) fn generics_of(&self, def_id: DefId) -> Generics { - self.cx.generics_of(def_id) + fn foreign_modules(&self, crate_num: CrateNum) -> Vec { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.foreign_modules(crate_num.internal(&mut *tables, cx)) + .iter() + .map(|did| tables.foreign_module_def(*did)) + .collect() } - pub(crate) fn predicates_of(&self, def_id: DefId) -> GenericPredicates { - self.cx.predicates_of(def_id) + /// Retrieve all functions defined in this crate. + fn crate_functions(&self, crate_num: CrateNum) -> Vec { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let tables_ref = &mut *tables; + let krate = crate_num.internal(tables_ref, cx); + cx.crate_functions(krate, tables_ref).iter().map(|did| tables.fn_def(*did)).collect() } - pub(crate) fn explicit_predicates_of(&self, def_id: DefId) -> GenericPredicates { - self.cx.explicit_predicates_of(def_id) + /// Retrieve all static items defined in this crate. + fn crate_statics(&self, crate_num: CrateNum) -> Vec { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let tables_ref = &mut *tables; + let krate = crate_num.internal(tables_ref, cx); + cx.crate_statics(krate, tables_ref).iter().map(|did| tables.static_def(*did)).collect() + } + + fn foreign_module(&self, mod_def: ForeignModuleDef) -> ForeignModule { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[mod_def.def_id()]; + cx.foreign_module(did).stable(&mut *tables, cx) + } + + fn foreign_items(&self, mod_def: ForeignModuleDef) -> Vec { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[mod_def.def_id()]; + cx.foreign_items(did).iter().map(|did| tables.foreign_def(*did)).collect() + } + + fn all_trait_decls(&self) -> TraitDecls { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.all_trait_decls().iter().map(|did| tables.trait_def(*did)).collect() + } + + fn trait_decls(&self, crate_num: CrateNum) -> TraitDecls { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let krate = crate_num.internal(&mut *tables, cx); + cx.trait_decls(krate).iter().map(|did| tables.trait_def(*did)).collect() + } + + fn trait_decl(&self, trait_def: &TraitDef) -> TraitDecl { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[trait_def.0]; + cx.trait_decl(did).stable(&mut *tables, cx) + } + + fn all_trait_impls(&self) -> ImplTraitDecls { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.all_trait_impls().iter().map(|did| tables.impl_def(*did)).collect() + } + + fn trait_impls(&self, crate_num: CrateNum) -> ImplTraitDecls { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let krate = crate_num.internal(&mut *tables, cx); + cx.trait_impls(krate).iter().map(|did| tables.impl_def(*did)).collect() + } + + fn trait_impl(&self, trait_impl: &ImplDef) -> ImplTrait { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[trait_impl.0]; + cx.trait_impl(did).stable(&mut *tables, cx) + } + + fn generics_of(&self, def_id: DefId) -> Generics { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[def_id]; + cx.generics_of(did).stable(&mut *tables, cx) + } + + fn predicates_of(&self, def_id: DefId) -> GenericPredicates { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[def_id]; + let rustc_middle::ty::GenericPredicates { parent, predicates } = cx.predicates_of(did); + stable_mir::ty::GenericPredicates { + parent: parent.map(|did| tables.trait_def(did)), + predicates: predicates + .iter() + .map(|(clause, span)| { + ( + clause.as_predicate().kind().skip_binder().stable(&mut *tables, cx), + span.stable(&mut *tables, cx), + ) + }) + .collect(), + } + } + + fn explicit_predicates_of(&self, def_id: DefId) -> GenericPredicates { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[def_id]; + let rustc_middle::ty::GenericPredicates { parent, predicates } = + cx.explicit_predicates_of(did); + stable_mir::ty::GenericPredicates { + parent: parent.map(|did| tables.trait_def(did)), + predicates: predicates + .iter() + .map(|(clause, span)| { + ( + clause.as_predicate().kind().skip_binder().stable(&mut *tables, cx), + span.stable(&mut *tables, cx), + ) + }) + .collect(), + } } /// Get information about the local crate. - pub(crate) fn local_crate(&self) -> Crate { - self.cx.local_crate() + fn local_crate(&self) -> Crate { + let cx = &*self.cx.borrow(); + self.smir_crate(cx.local_crate_num()) } /// Retrieve a list of all external crates. - pub(crate) fn external_crates(&self) -> Vec { - self.cx.external_crates() + fn external_crates(&self) -> Vec { + let cx = &*self.cx.borrow(); + cx.external_crates().iter().map(|crate_num| self.smir_crate(*crate_num)).collect() } /// Find a crate with the given name. - pub(crate) fn find_crates(&self, name: &str) -> Vec { - self.cx.find_crates(name) + fn find_crates(&self, name: &str) -> Vec { + let cx = &*self.cx.borrow(); + cx.find_crates(name).iter().map(|crate_num| self.smir_crate(*crate_num)).collect() } /// Returns the name of given `DefId`. - pub(crate) fn def_name(&self, def_id: DefId, trimmed: bool) -> Symbol { - self.cx.def_name(def_id, trimmed) + fn def_name(&self, def_id: DefId, trimmed: bool) -> Symbol { + let tables = self.tables.borrow(); + let cx = &*self.cx.borrow(); + let did = tables[def_id]; + cx.def_name(did, trimmed) } /// Return registered tool attributes with the given attribute name. @@ -141,63 +594,111 @@ impl<'tcx> SmirInterface<'tcx> { /// /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`. /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`. - pub(crate) fn tool_attrs(&self, def_id: DefId, attr: &[Symbol]) -> Vec { - self.cx.tool_attrs(def_id, attr) + fn tool_attrs(&self, def_id: DefId, attr: &[Symbol]) -> Vec { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[def_id]; + cx.tool_attrs(did, attr) + .into_iter() + .map(|(attr_str, span)| Attribute::new(attr_str, span.stable(&mut *tables, cx))) + .collect() } /// Get all tool attributes of a definition. - pub(crate) fn all_tool_attrs(&self, def_id: DefId) -> Vec { - self.cx.all_tool_attrs(def_id) + fn all_tool_attrs(&self, def_id: DefId) -> Vec { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[def_id]; + cx.all_tool_attrs(did) + .into_iter() + .map(|(attr_str, span)| Attribute::new(attr_str, span.stable(&mut *tables, cx))) + .collect() } /// Returns printable, human readable form of `Span`. - pub(crate) fn span_to_string(&self, span: Span) -> String { - self.cx.span_to_string(span) + fn span_to_string(&self, span: Span) -> String { + let tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let sp = tables.spans[span]; + cx.span_to_string(sp) } /// Return filename from given `Span`, for diagnostic purposes. - pub(crate) fn get_filename(&self, span: &Span) -> Filename { - self.cx.get_filename(span) + fn get_filename(&self, span: &Span) -> Filename { + let tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let sp = tables.spans[*span]; + cx.get_filename(sp) } /// Return lines corresponding to this `Span`. - pub(crate) fn get_lines(&self, span: &Span) -> LineInfo { - self.cx.get_lines(span) + fn get_lines(&self, span: &Span) -> LineInfo { + let tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let sp = tables.spans[*span]; + let lines = cx.get_lines(sp); + LineInfo::from(lines) } /// Returns the `kind` of given `DefId`. - pub(crate) fn item_kind(&self, item: CrateItem) -> ItemKind { - self.cx.item_kind(item) + fn item_kind(&self, item: CrateItem) -> ItemKind { + let tables = self.tables.borrow(); + let cx = &*self.cx.borrow(); + let did = tables[item.0]; + new_item_kind(cx.def_kind(did)) } /// Returns whether this is a foreign item. - pub(crate) fn is_foreign_item(&self, item: DefId) -> bool { - self.cx.is_foreign_item(item) + fn is_foreign_item(&self, item: DefId) -> bool { + let tables = self.tables.borrow(); + let cx = &*self.cx.borrow(); + let did = tables[item]; + cx.is_foreign_item(did) } /// Returns the kind of a given foreign item. - pub(crate) fn foreign_item_kind(&self, def: ForeignDef) -> ForeignItemKind { - self.cx.foreign_item_kind(def) + fn foreign_item_kind(&self, def: ForeignDef) -> ForeignItemKind { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let def_id = tables[def.def_id()]; + let def_kind = cx.foreign_item_kind(def_id); + match def_kind { + DefKind::Fn => ForeignItemKind::Fn(tables.fn_def(def_id)), + DefKind::Static { .. } => ForeignItemKind::Static(tables.static_def(def_id)), + DefKind::ForeignTy => { + use rustc_smir::context::SmirTy; + ForeignItemKind::Type(tables.intern_ty(cx.new_foreign(def_id))) + } + def_kind => unreachable!("Unexpected kind for a foreign item: {:?}", def_kind), + } } /// Returns the kind of a given algebraic data type. - pub(crate) fn adt_kind(&self, def: AdtDef) -> AdtKind { - self.cx.adt_kind(def) + fn adt_kind(&self, def: AdtDef) -> AdtKind { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.adt_kind(def.internal(&mut *tables, cx)).stable(&mut *tables, cx) } /// Returns if the ADT is a box. - pub(crate) fn adt_is_box(&self, def: AdtDef) -> bool { - self.cx.adt_is_box(def) + fn adt_is_box(&self, def: AdtDef) -> bool { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.adt_is_box(def.internal(&mut *tables, cx)) } /// Returns whether this ADT is simd. - pub(crate) fn adt_is_simd(&self, def: AdtDef) -> bool { - self.cx.adt_is_simd(def) + fn adt_is_simd(&self, def: AdtDef) -> bool { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.adt_is_simd(def.internal(&mut *tables, cx)) } /// Returns whether this definition is a C string. - pub(crate) fn adt_is_cstr(&self, def: AdtDef) -> bool { - self.cx.adt_is_cstr(def) + fn adt_is_cstr(&self, def: AdtDef) -> bool { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.adt_is_cstr(def.0.internal(&mut *tables, cx)) } /// Returns the representation options for this ADT @@ -206,28 +707,43 @@ impl<'tcx> SmirInterface<'tcx> { } /// Retrieve the function signature for the given generic arguments. - pub(crate) fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig { - self.cx.fn_sig(def, args) + fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let def_id = def.0.internal(&mut *tables, cx); + let args_ref = args.internal(&mut *tables, cx); + cx.fn_sig(def_id, args_ref).stable(&mut *tables, cx) } /// Retrieve the intrinsic definition if the item corresponds one. - pub(crate) fn intrinsic(&self, item: DefId) -> Option { - self.cx.intrinsic(item) + fn intrinsic(&self, item: DefId) -> Option { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let def_id = item.internal(&mut *tables, cx); + cx.intrinsic(def_id).map(|_| IntrinsicDef(item)) } /// Retrieve the plain function name of an intrinsic. - pub(crate) fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol { - self.cx.intrinsic_name(def) + fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let def_id = def.0.internal(&mut *tables, cx); + cx.intrinsic_name(def_id) } /// Retrieve the closure signature for the given generic arguments. - pub(crate) fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig { - self.cx.closure_sig(args) + fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let args_ref = args.internal(&mut *tables, cx); + cx.closure_sig(args_ref).stable(&mut *tables, cx) } /// The number of variants in this ADT. - pub(crate) fn adt_variants_len(&self, def: AdtDef) -> usize { - self.cx.adt_variants_len(def) + fn adt_variants_len(&self, def: AdtDef) -> usize { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.adt_variants_len(def.internal(&mut *tables, cx)) } /// Discriminant for a given variant index of AdtDef @@ -246,259 +762,405 @@ impl<'tcx> SmirInterface<'tcx> { } /// The name of a variant. - pub(crate) fn variant_name(&self, def: VariantDef) -> Symbol { - self.cx.variant_name(def) + fn variant_name(&self, def: VariantDef) -> Symbol { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.variant_name(def.internal(&mut *tables, cx)) } - pub(crate) fn variant_fields(&self, def: VariantDef) -> Vec { - self.cx.variant_fields(def) + fn variant_fields(&self, def: VariantDef) -> Vec { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + def.internal(&mut *tables, cx).fields.iter().map(|f| f.stable(&mut *tables, cx)).collect() } /// Evaluate constant as a target usize. - pub(crate) fn eval_target_usize(&self, cnst: &MirConst) -> Result { - self.cx.eval_target_usize(cnst) + fn eval_target_usize(&self, mir_const: &MirConst) -> Result { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let cnst = mir_const.internal(&mut *tables, cx); + cx.eval_target_usize(cnst) } - pub(crate) fn eval_target_usize_ty(&self, cnst: &TyConst) -> Result { - self.cx.eval_target_usize_ty(cnst) + fn eval_target_usize_ty(&self, ty_const: &TyConst) -> Result { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let cnst = ty_const.internal(&mut *tables, cx); + cx.eval_target_usize_ty(cnst) } /// Create a new zero-sized constant. - pub(crate) fn try_new_const_zst(&self, ty: Ty) -> Result { - self.cx.try_new_const_zst(ty) + fn try_new_const_zst(&self, ty: Ty) -> Result { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let ty_internal = ty.internal(&mut *tables, cx); + cx.try_new_const_zst(ty_internal).map(|cnst| cnst.stable(&mut *tables, cx)) } /// Create a new constant that represents the given string value. - pub(crate) fn new_const_str(&self, value: &str) -> MirConst { - self.cx.new_const_str(value) + fn new_const_str(&self, value: &str) -> MirConst { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.new_const_str(value).stable(&mut *tables, cx) } /// Create a new constant that represents the given boolean value. - pub(crate) fn new_const_bool(&self, value: bool) -> MirConst { - self.cx.new_const_bool(value) + fn new_const_bool(&self, value: bool) -> MirConst { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.new_const_bool(value).stable(&mut *tables, cx) } /// Create a new constant that represents the given value. - pub(crate) fn try_new_const_uint( - &self, - value: u128, - uint_ty: UintTy, - ) -> Result { - self.cx.try_new_const_uint(value, uint_ty) + fn try_new_const_uint(&self, value: u128, uint_ty: UintTy) -> Result { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let ty = cx.ty_new_uint(uint_ty.internal(&mut *tables, cx)); + cx.try_new_const_uint(value, ty).map(|cnst| cnst.stable(&mut *tables, cx)) } - pub(crate) fn try_new_ty_const_uint( - &self, - value: u128, - uint_ty: UintTy, - ) -> Result { - self.cx.try_new_ty_const_uint(value, uint_ty) + fn try_new_ty_const_uint(&self, value: u128, uint_ty: UintTy) -> Result { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let ty = cx.ty_new_uint(uint_ty.internal(&mut *tables, cx)); + cx.try_new_ty_const_uint(value, ty).map(|cnst| cnst.stable(&mut *tables, cx)) } /// Create a new type from the given kind. - pub(crate) fn new_rigid_ty(&self, kind: RigidTy) -> Ty { - self.cx.new_rigid_ty(kind) + fn new_rigid_ty(&self, kind: RigidTy) -> Ty { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let internal_kind = kind.internal(&mut *tables, cx); + cx.new_rigid_ty(internal_kind).stable(&mut *tables, cx) } /// Create a new box type, `Box`, for the given inner type `T`. - pub(crate) fn new_box_ty(&self, ty: Ty) -> Ty { - self.cx.new_box_ty(ty) + fn new_box_ty(&self, ty: Ty) -> Ty { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let inner = ty.internal(&mut *tables, cx); + cx.new_box_ty(inner).stable(&mut *tables, cx) } /// Returns the type of given crate item. - pub(crate) fn def_ty(&self, item: DefId) -> Ty { - self.cx.def_ty(item) + fn def_ty(&self, item: DefId) -> Ty { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let inner = item.internal(&mut *tables, cx); + cx.def_ty(inner).stable(&mut *tables, cx) } /// Returns the type of given definition instantiated with the given arguments. - pub(crate) fn def_ty_with_args(&self, item: DefId, args: &GenericArgs) -> Ty { - self.cx.def_ty_with_args(item, args) + fn def_ty_with_args(&self, item: DefId, args: &GenericArgs) -> Ty { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let inner = item.internal(&mut *tables, cx); + let args_ref = args.internal(&mut *tables, cx); + cx.def_ty_with_args(inner, args_ref).stable(&mut *tables, cx) } /// Returns literal value of a const as a string. - pub(crate) fn mir_const_pretty(&self, cnst: &MirConst) -> String { - self.cx.mir_const_pretty(cnst) + fn mir_const_pretty(&self, cnst: &MirConst) -> String { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cnst.internal(&mut *tables, cx).to_string() } /// `Span` of an item. - pub(crate) fn span_of_an_item(&self, def_id: DefId) -> Span { - self.cx.span_of_an_item(def_id) + fn span_of_an_item(&self, def_id: DefId) -> Span { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[def_id]; + cx.span_of_an_item(did).stable(&mut *tables, cx) } - pub(crate) fn ty_const_pretty(&self, ct: TyConstId) -> String { - self.cx.ty_const_pretty(ct) + fn ty_const_pretty(&self, ct: TyConstId) -> String { + let tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.ty_const_pretty(tables.ty_consts[ct]) } /// Obtain the representation of a type. - pub(crate) fn ty_pretty(&self, ty: Ty) -> String { - self.cx.ty_pretty(ty) + fn ty_pretty(&self, ty: Ty) -> String { + let tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.ty_pretty(tables.types[ty]) } - /// Obtain the representation of a type. - pub(crate) fn ty_kind(&self, ty: Ty) -> TyKind { - self.cx.ty_kind(ty) + /// Obtain the kind of a type. + fn ty_kind(&self, ty: Ty) -> TyKind { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.ty_kind(tables.types[ty]).stable(&mut *tables, cx) } /// Get the discriminant Ty for this Ty if there's one. - pub(crate) fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> Ty { - self.cx.rigid_ty_discriminant_ty(ty) + fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> Ty { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let internal_kind = ty.internal(&mut *tables, cx); + cx.rigid_ty_discriminant_ty(internal_kind).stable(&mut *tables, cx) } /// Get the body of an Instance which is already monomorphized. - pub(crate) fn instance_body(&self, instance: InstanceDef) -> Option { - self.cx.instance_body(instance) + fn instance_body(&self, instance: InstanceDef) -> Option { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let instance = tables.instances[instance]; + cx.instance_body(instance, &mut *tables).map(|body| body.stable(&mut *tables, cx)) } /// Get the instance type with generic instantiations applied and lifetimes erased. - pub(crate) fn instance_ty(&self, instance: InstanceDef) -> Ty { - self.cx.instance_ty(instance) + fn instance_ty(&self, instance: InstanceDef) -> Ty { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let instance = tables.instances[instance]; + cx.instance_ty(instance).stable(&mut *tables, cx) } /// Get the instantiation types. - pub(crate) fn instance_args(&self, def: InstanceDef) -> GenericArgs { - self.cx.instance_args(def) + fn instance_args(&self, def: InstanceDef) -> GenericArgs { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let instance = tables.instances[def]; + cx.instance_args(instance).stable(&mut *tables, cx) } /// Get the instance. - pub(crate) fn instance_def_id(&self, instance: InstanceDef) -> DefId { - self.cx.instance_def_id(instance) + fn instance_def_id(&self, instance: InstanceDef) -> DefId { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let instance = tables.instances[instance]; + cx.instance_def_id(instance, &mut *tables) } /// Get the instance mangled name. - pub(crate) fn instance_mangled_name(&self, instance: InstanceDef) -> Symbol { - self.cx.instance_mangled_name(instance) + fn instance_mangled_name(&self, instance: InstanceDef) -> Symbol { + let tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let instance = tables.instances[instance]; + cx.instance_mangled_name(instance) } /// Check if this is an empty DropGlue shim. - pub(crate) fn is_empty_drop_shim(&self, def: InstanceDef) -> bool { - self.cx.is_empty_drop_shim(def) + fn is_empty_drop_shim(&self, def: InstanceDef) -> bool { + let tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let instance = tables.instances[def]; + cx.is_empty_drop_shim(instance) } /// Convert a non-generic crate item into an instance. /// This function will panic if the item is generic. - pub(crate) fn mono_instance(&self, def_id: DefId) -> Instance { - self.cx.mono_instance(def_id) + fn mono_instance(&self, def_id: DefId) -> Instance { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[def_id]; + cx.mono_instance(did).stable(&mut *tables, cx) } /// Item requires monomorphization. - pub(crate) fn requires_monomorphization(&self, def_id: DefId) -> bool { - self.cx.requires_monomorphization(def_id) + fn requires_monomorphization(&self, def_id: DefId) -> bool { + let tables = self.tables.borrow(); + let cx = &*self.cx.borrow(); + let did = tables[def_id]; + cx.requires_monomorphization(did) } /// Resolve an instance from the given function definition and generic arguments. - pub(crate) fn resolve_instance(&self, def: FnDef, args: &GenericArgs) -> Option { - self.cx.resolve_instance(def, args) + fn resolve_instance(&self, def: FnDef, args: &GenericArgs) -> Option { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let def_id = def.0.internal(&mut *tables, cx); + let args_ref = args.internal(&mut *tables, cx); + cx.resolve_instance(def_id, args_ref).map(|inst| inst.stable(&mut *tables, cx)) } /// Resolve an instance for drop_in_place for the given type. - pub(crate) fn resolve_drop_in_place(&self, ty: Ty) -> Instance { - self.cx.resolve_drop_in_place(ty) + fn resolve_drop_in_place(&self, ty: Ty) -> Instance { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let internal_ty = ty.internal(&mut *tables, cx); + + cx.resolve_drop_in_place(internal_ty).stable(&mut *tables, cx) } /// Resolve instance for a function pointer. - pub(crate) fn resolve_for_fn_ptr(&self, def: FnDef, args: &GenericArgs) -> Option { - self.cx.resolve_for_fn_ptr(def, args) + fn resolve_for_fn_ptr(&self, def: FnDef, args: &GenericArgs) -> Option { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let def_id = def.0.internal(&mut *tables, cx); + let args_ref = args.internal(&mut *tables, cx); + cx.resolve_for_fn_ptr(def_id, args_ref).stable(&mut *tables, cx) } /// Resolve instance for a closure with the requested type. - pub(crate) fn resolve_closure( + fn resolve_closure( &self, def: ClosureDef, args: &GenericArgs, kind: ClosureKind, ) -> Option { - self.cx.resolve_closure(def, args, kind) + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let def_id = def.0.internal(&mut *tables, cx); + let args_ref = args.internal(&mut *tables, cx); + let closure_kind = kind.internal(&mut *tables, cx); + cx.resolve_closure(def_id, args_ref, closure_kind).map(|inst| inst.stable(&mut *tables, cx)) } /// Evaluate a static's initializer. - pub(crate) fn eval_static_initializer(&self, def: StaticDef) -> Result { - self.cx.eval_static_initializer(def) + fn eval_static_initializer(&self, def: StaticDef) -> Result { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let def_id = def.0.internal(&mut *tables, cx); + + cx.eval_static_initializer(def_id).stable(&mut *tables, cx) } /// Try to evaluate an instance into a constant. - pub(crate) fn eval_instance( - &self, - def: InstanceDef, - const_ty: Ty, - ) -> Result { - self.cx.eval_instance(def, const_ty) + fn eval_instance(&self, def: InstanceDef, const_ty: Ty) -> Result { + let mut tables = self.tables.borrow_mut(); + let instance = tables.instances[def]; + let cx = &*self.cx.borrow(); + let const_ty = const_ty.internal(&mut *tables, cx); + cx.eval_instance(instance) + .map(|const_val| alloc::try_new_allocation(const_ty, const_val, &mut *tables, cx)) + .map_err(|e| e.stable(&mut *tables, cx))? } /// Retrieve global allocation for the given allocation ID. - pub(crate) fn global_alloc(&self, id: AllocId) -> GlobalAlloc { - self.cx.global_alloc(id) + fn global_alloc(&self, id: AllocId) -> GlobalAlloc { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let alloc_id = id.internal(&mut *tables, cx); + cx.global_alloc(alloc_id).stable(&mut *tables, cx) } /// Retrieve the id for the virtual table. - pub(crate) fn vtable_allocation(&self, global_alloc: &GlobalAlloc) -> Option { - self.cx.vtable_allocation(global_alloc) + fn vtable_allocation(&self, global_alloc: &GlobalAlloc) -> Option { + let mut tables = self.tables.borrow_mut(); + let GlobalAlloc::VTable(ty, trait_ref) = global_alloc else { + return None; + }; + let cx = &*self.cx.borrow(); + let ty = ty.internal(&mut *tables, cx); + let trait_ref = trait_ref.internal(&mut *tables, cx); + let alloc_id = cx.vtable_allocation(ty, trait_ref); + Some(alloc_id.stable(&mut *tables, cx)) } - pub(crate) fn krate(&self, def_id: DefId) -> Crate { - self.cx.krate(def_id) + fn krate(&self, def_id: DefId) -> Crate { + let tables = self.tables.borrow(); + self.smir_crate(tables[def_id].krate) } - pub(crate) fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol { - self.cx.instance_name(def, trimmed) + fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol { + let tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let instance = tables.instances[def]; + cx.instance_name(instance, trimmed) } /// Return information about the target machine. - pub(crate) fn target_info(&self) -> MachineInfo { - self.cx.target_info() + fn target_info(&self) -> MachineInfo { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + MachineInfo { + endian: cx.target_endian().stable(&mut *tables, cx), + pointer_width: MachineSize::from_bits(cx.target_pointer_size()), + } } /// Get an instance ABI. - pub(crate) fn instance_abi(&self, def: InstanceDef) -> Result { - self.cx.instance_abi(def) + fn instance_abi(&self, def: InstanceDef) -> Result { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let instance = tables.instances[def]; + cx.instance_abi(instance, &mut *tables).map(|fn_abi| fn_abi.stable(&mut *tables, cx)) } /// Get the ABI of a function pointer. - pub(crate) fn fn_ptr_abi(&self, fn_ptr: PolyFnSig) -> Result { - self.cx.fn_ptr_abi(fn_ptr) + fn fn_ptr_abi(&self, fn_ptr: PolyFnSig) -> Result { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let sig = fn_ptr.internal(&mut *tables, cx); + cx.fn_ptr_abi(sig, &mut *tables).map(|fn_abi| fn_abi.stable(&mut *tables, cx)) } /// Get the layout of a type. - pub(crate) fn ty_layout(&self, ty: Ty) -> Result { - self.cx.ty_layout(ty) + fn ty_layout(&self, ty: Ty) -> Result { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let internal_ty = ty.internal(&mut *tables, cx); + cx.ty_layout(internal_ty, &mut *tables).map(|layout| layout.stable(&mut *tables, cx)) } /// Get the layout shape. - pub(crate) fn layout_shape(&self, id: Layout) -> LayoutShape { - self.cx.layout_shape(id) + fn layout_shape(&self, id: Layout) -> LayoutShape { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + id.internal(&mut *tables, cx).0.stable(&mut *tables, cx) } /// Get a debug string representation of a place. - pub(crate) fn place_pretty(&self, place: &Place) -> String { - self.cx.place_pretty(place) + fn place_pretty(&self, place: &Place) -> String { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + + format!("{:?}", place.internal(&mut *tables, cx)) } /// Get the resulting type of binary operation. - pub(crate) fn binop_ty(&self, bin_op: BinOp, rhs: Ty, lhs: Ty) -> Ty { - self.cx.binop_ty(bin_op, rhs, lhs) + fn binop_ty(&self, bin_op: BinOp, rhs: Ty, lhs: Ty) -> Ty { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let rhs_internal = rhs.internal(&mut *tables, cx); + let lhs_internal = lhs.internal(&mut *tables, cx); + let bin_op_internal = bin_op.internal(&mut *tables, cx); + cx.binop_ty(bin_op_internal, rhs_internal, lhs_internal).stable(&mut *tables, cx) } /// Get the resulting type of unary operation. - pub(crate) fn unop_ty(&self, un_op: UnOp, arg: Ty) -> Ty { - self.cx.unop_ty(un_op, arg) + fn unop_ty(&self, un_op: UnOp, arg: Ty) -> Ty { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let un_op = un_op.internal(&mut *tables, cx); + let arg = arg.internal(&mut *tables, cx); + cx.unop_ty(un_op, arg).stable(&mut *tables, cx) } /// Get all associated items of a definition. - pub(crate) fn associated_items(&self, def_id: DefId) -> AssocItems { - self.cx.associated_items(def_id) + fn associated_items(&self, def_id: DefId) -> AssocItems { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let did = tables[def_id]; + cx.associated_items(did).iter().map(|assoc| assoc.stable(&mut *tables, cx)).collect() + } +} + +impl<'tcx> SmirContainer<'tcx, BridgeTys> { + fn smir_crate(&self, crate_num: rustc_span::def_id::CrateNum) -> Crate { + let cx = &*self.cx.borrow(); + let name = cx.crate_name(crate_num); + let is_local = cx.crate_is_local(crate_num); + let id = cx.crate_num_id(crate_num); + debug!(?name, ?crate_num, "smir_crate"); + Crate { id, name, is_local } } } // A thread local variable that stores a pointer to [`SmirInterface`]. scoped_tls::scoped_thread_local!(static TLV: Cell<*const ()>); -pub(crate) fn run<'tcx, T, F>(interface: &SmirInterface<'tcx>, f: F) -> Result +pub(crate) fn run(interface: &dyn SmirInterface, f: F) -> Result where F: FnOnce() -> T, { if TLV.is_set() { Err(Error::from("StableMIR already running")) } else { - let ptr: *const () = (interface as *const SmirInterface<'tcx>) as *const (); + let ptr: *const () = (&raw const interface) as _; TLV.set(&Cell::new(ptr), || Ok(f())) } } @@ -507,11 +1169,11 @@ where /// /// I.e., This function will load the current interface and calls a function with it. /// Do not nest these, as that will ICE. -pub(crate) fn with(f: impl FnOnce(&SmirInterface<'_>) -> R) -> R { +pub(crate) fn with(f: impl FnOnce(&dyn SmirInterface) -> R) -> R { assert!(TLV.is_set()); TLV.with(|tlv| { let ptr = tlv.get(); assert!(!ptr.is_null()); - f(unsafe { &*(ptr as *const SmirInterface<'_>) }) + f(unsafe { *(ptr as *const &dyn SmirInterface) }) }) } diff --git a/compiler/rustc_smir/src/stable_mir/mod.rs b/compiler/rustc_smir/src/stable_mir/mod.rs index c59758d4ad3f2..0ced493b9ab51 100644 --- a/compiler/rustc_smir/src/stable_mir/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/mod.rs @@ -27,6 +27,7 @@ use std::fmt::Debug; use std::{fmt, io}; +use rustc_hir::def::DefKind; use serde::Serialize; use stable_mir::compiler_interface::with; pub use stable_mir::crate_def::{CrateDef, CrateDefItems, CrateDefType, DefId}; @@ -218,6 +219,43 @@ pub fn all_trait_impls() -> ImplTraitDecls { with(|cx| cx.all_trait_impls()) } +pub(crate) fn new_item_kind(kind: DefKind) -> ItemKind { + match kind { + DefKind::Mod + | DefKind::Struct + | DefKind::Union + | DefKind::Enum + | DefKind::Variant + | DefKind::Trait + | DefKind::TyAlias + | DefKind::ForeignTy + | DefKind::TraitAlias + | DefKind::AssocTy + | DefKind::TyParam + | DefKind::ConstParam + | DefKind::Macro(_) + | DefKind::ExternCrate + | DefKind::Use + | DefKind::ForeignMod + | DefKind::OpaqueTy + | DefKind::Field + | DefKind::LifetimeParam + | DefKind::Impl { .. } + | DefKind::GlobalAsm => { + unreachable!("Not a valid item kind: {kind:?}"); + } + DefKind::Closure | DefKind::AssocFn | DefKind::Fn | DefKind::SyntheticCoroutineBody => { + ItemKind::Fn + } + DefKind::Const | DefKind::InlineConst | DefKind::AssocConst | DefKind::AnonConst => { + ItemKind::Const + } + DefKind::Static { .. } => ItemKind::Static, + DefKind::Ctor(_, rustc_hir::def::CtorKind::Const) => ItemKind::Ctor(CtorKind::Const), + DefKind::Ctor(_, rustc_hir::def::CtorKind::Fn) => ItemKind::Ctor(CtorKind::Fn), + } +} + /// A type that provides internal information but that can still be used for debug purpose. #[derive(Clone, PartialEq, Eq, Hash, Serialize)] pub struct Opaque(String); diff --git a/compiler/rustc_smir/src/stable_mir/ty.rs b/compiler/rustc_smir/src/stable_mir/ty.rs index 4415cd6e2e3ba..8f455ee95c846 100644 --- a/compiler/rustc_smir/src/stable_mir/ty.rs +++ b/compiler/rustc_smir/src/stable_mir/ty.rs @@ -298,6 +298,12 @@ pub struct LineInfo { pub end_col: usize, } +impl LineInfo { + pub fn from(lines: (usize, usize, usize, usize)) -> Self { + LineInfo { start_line: lines.0, start_col: lines.1, end_line: lines.2, end_col: lines.3 } + } +} + #[derive(Clone, Debug, Eq, PartialEq, Serialize)] pub enum TyKind { RigidTy(RigidTy), From 8c7f4ed6a0f3d3438edabcf8a170e15694d74271 Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 5 May 2025 15:20:40 +0800 Subject: [PATCH 03/22] refactor: move `IndexedVal` from `stable_mir` to `rustc_smir` --- compiler/rustc_smir/src/rustc_internal/mod.rs | 3 +-- compiler/rustc_smir/src/rustc_smir/mod.rs | 7 ++++++- compiler/rustc_smir/src/stable_mir/abi.rs | 4 ++-- compiler/rustc_smir/src/stable_mir/mir/alloc.rs | 5 +++-- compiler/rustc_smir/src/stable_mir/mir/pretty.rs | 5 +++-- compiler/rustc_smir/src/stable_mir/mod.rs | 5 +++-- compiler/rustc_smir/src/stable_mir/ty.rs | 11 +++-------- 7 files changed, 21 insertions(+), 19 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs index 3434c9fbf928d..c343242ddfc57 100644 --- a/compiler/rustc_smir/src/rustc_internal/mod.rs +++ b/compiler/rustc_smir/src/rustc_internal/mod.rs @@ -17,11 +17,10 @@ use rustc_span::Span; use rustc_span::def_id::{CrateNum, DefId}; use scoped_tls::scoped_thread_local; use stable_mir::Error; -use stable_mir::ty::IndexedVal; use crate::rustc_smir::context::SmirCtxt; use crate::rustc_smir::{Stable, Tables}; -use crate::rustc_smir::{Bridge, SmirContainer, Tables}; +use crate::rustc_smir::{Bridge, IndexedVal, SmirContainer, Tables}; use crate::stable_mir; mod internal; diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs index 2f5a9ea9a1ec9..9ce5520ee8e40 100644 --- a/compiler/rustc_smir/src/rustc_smir/mod.rs +++ b/compiler/rustc_smir/src/rustc_smir/mod.rs @@ -19,7 +19,6 @@ use rustc_middle::ty::{self, Instance, Ty, TyCtxt}; use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE}; use crate::rustc_internal::IndexMap; -use crate::stable_mir; mod alloc; mod builder; @@ -133,6 +132,12 @@ pub trait SmirError { fn from_internal(err: T) -> Self; } +pub trait IndexedVal { + fn to_val(index: usize) -> Self; + + fn to_index(&self) -> usize; +} + /// Iterate over the definitions of the given crate. pub(crate) fn filter_def_ids(tcx: TyCtxt<'_>, krate: CrateNum, mut func: F) -> Vec where diff --git a/compiler/rustc_smir/src/stable_mir/abi.rs b/compiler/rustc_smir/src/stable_mir/abi.rs index d8a2b97662c45..3c8bdb243d4c2 100644 --- a/compiler/rustc_smir/src/stable_mir/abi.rs +++ b/compiler/rustc_smir/src/stable_mir/abi.rs @@ -6,7 +6,7 @@ use serde::Serialize; use stable_mir::compiler_interface::with; use stable_mir::mir::FieldIdx; use stable_mir::target::{MachineInfo, MachineSize as Size}; -use stable_mir::ty::{Align, IndexedVal, Ty, VariantIdx}; +use stable_mir::ty::{Align, Ty, VariantIdx}; use stable_mir::{Error, Opaque, error}; use crate::stable_mir; @@ -119,7 +119,7 @@ impl Layout { } } -impl IndexedVal for Layout { +impl crate::rustc_smir::IndexedVal for Layout { fn to_val(index: usize) -> Self { Layout(index) } diff --git a/compiler/rustc_smir/src/stable_mir/mir/alloc.rs b/compiler/rustc_smir/src/stable_mir/mir/alloc.rs index 782f52888b73d..325f26da8bbf3 100644 --- a/compiler/rustc_smir/src/stable_mir/mir/alloc.rs +++ b/compiler/rustc_smir/src/stable_mir/mir/alloc.rs @@ -2,13 +2,14 @@ use std::io::Read; +use rustc_smir::IndexedVal; use serde::Serialize; use stable_mir::mir::mono::{Instance, StaticDef}; use stable_mir::target::{Endian, MachineInfo}; -use stable_mir::ty::{Allocation, Binder, ExistentialTraitRef, IndexedVal, Ty}; +use stable_mir::ty::{Allocation, Binder, ExistentialTraitRef, Ty}; use stable_mir::{Error, with}; -use crate::stable_mir; +use crate::{rustc_smir, stable_mir}; /// An allocation in the SMIR global memory can be either a function pointer, /// a static, or a "real" allocation with some data in it. diff --git a/compiler/rustc_smir/src/stable_mir/mir/pretty.rs b/compiler/rustc_smir/src/stable_mir/mir/pretty.rs index ba20651f993d1..b44afb1dc688b 100644 --- a/compiler/rustc_smir/src/stable_mir/mir/pretty.rs +++ b/compiler/rustc_smir/src/stable_mir/mir/pretty.rs @@ -4,14 +4,15 @@ use std::io::Write; use std::{fmt, io, iter}; use fmt::{Display, Formatter}; +use rustc_smir::IndexedVal; use stable_mir::mir::{ Operand, Place, RawPtrKind, Rvalue, StatementKind, UnwindAction, VarDebugInfoContents, }; -use stable_mir::ty::{AdtKind, AssocKind, IndexedVal, MirConst, Ty, TyConst}; +use stable_mir::ty::{AdtKind, AssocKind, MirConst, Ty, TyConst}; use stable_mir::{Body, CrateDef, Mutability, with}; use super::{AggregateKind, AssertMessage, BinOp, BorrowKind, FakeBorrowKind, TerminatorKind}; -use crate::stable_mir; +use crate::{rustc_smir, stable_mir}; impl Display for Ty { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { diff --git a/compiler/rustc_smir/src/stable_mir/mod.rs b/compiler/rustc_smir/src/stable_mir/mod.rs index 0ced493b9ab51..1c992ec5dbb7e 100644 --- a/compiler/rustc_smir/src/stable_mir/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/mod.rs @@ -28,15 +28,16 @@ use std::fmt::Debug; use std::{fmt, io}; use rustc_hir::def::DefKind; +use rustc_smir::IndexedVal; use serde::Serialize; use stable_mir::compiler_interface::with; pub use stable_mir::crate_def::{CrateDef, CrateDefItems, CrateDefType, DefId}; pub use stable_mir::error::*; use stable_mir::mir::mono::StaticDef; use stable_mir::mir::{Body, Mutability}; -use stable_mir::ty::{AssocItem, FnDef, ForeignModuleDef, ImplDef, IndexedVal, Span, TraitDef, Ty}; +use stable_mir::ty::{AssocItem, FnDef, ForeignModuleDef, ImplDef, Span, TraitDef, Ty}; -use crate::stable_mir; +use crate::{rustc_smir, stable_mir}; pub mod abi; #[macro_use] diff --git a/compiler/rustc_smir/src/stable_mir/ty.rs b/compiler/rustc_smir/src/stable_mir/ty.rs index 8f455ee95c846..5a9473df8e392 100644 --- a/compiler/rustc_smir/src/stable_mir/ty.rs +++ b/compiler/rustc_smir/src/stable_mir/ty.rs @@ -1,6 +1,7 @@ use std::fmt::{self, Debug, Display, Formatter}; use std::ops::Range; +use rustc_smir::IndexedVal; use serde::Serialize; use stable_mir::abi::{FnAbi, Layout}; use stable_mir::crate_def::{CrateDef, CrateDefItems, CrateDefType}; @@ -12,7 +13,7 @@ use stable_mir::{Filename, Opaque}; use super::abi::ReprOptions; use super::mir::{Body, Mutability, Safety}; use super::{DefId, Error, Symbol, with}; -use crate::stable_mir; +use crate::{rustc_smir, stable_mir}; #[derive(Copy, Clone, Eq, PartialEq, Hash, Serialize)] pub struct Ty(usize); @@ -1557,15 +1558,9 @@ pub enum PredicatePolarity { Negative, } -pub trait IndexedVal { - fn to_val(index: usize) -> Self; - - fn to_index(&self) -> usize; -} - macro_rules! index_impl { ($name:ident) => { - impl IndexedVal for $name { + impl crate::rustc_smir::IndexedVal for $name { fn to_val(index: usize) -> Self { $name(index) } From 336c10b9a6aaef31667c5734c298acba78be7639 Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 5 May 2025 15:22:48 +0800 Subject: [PATCH 04/22] refactor: impl `SmirError` for `stable_mir::Error` --- compiler/rustc_smir/src/stable_mir/error.rs | 12 ++++++++++-- compiler/rustc_smir/src/stable_mir/mir/mono.rs | 5 +++-- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_smir/src/stable_mir/error.rs b/compiler/rustc_smir/src/stable_mir/error.rs index 050752e41eb92..c6bf96ebd1763 100644 --- a/compiler/rustc_smir/src/stable_mir/error.rs +++ b/compiler/rustc_smir/src/stable_mir/error.rs @@ -7,6 +7,10 @@ use std::fmt::{Debug, Display, Formatter}; use std::{fmt, io}; +use rustc_smir::SmirError; + +use crate::rustc_smir; + macro_rules! error { ($fmt: literal $(,)?) => { Error(format!($fmt)) }; ($fmt: literal, $($arg:tt)*) => { Error(format!($fmt, $($arg)*)) }; @@ -30,10 +34,14 @@ pub enum CompilerError { #[derive(Clone, Debug, Eq, PartialEq)] pub struct Error(pub(crate) String); -impl Error { - pub fn new(msg: String) -> Self { +impl SmirError for Error { + fn new(msg: String) -> Self { Self(msg) } + + fn from_internal(err: T) -> Self { + Self(format!("{err:?}")) + } } impl From<&str> for Error { diff --git a/compiler/rustc_smir/src/stable_mir/mir/mono.rs b/compiler/rustc_smir/src/stable_mir/mir/mono.rs index f5239cccae1eb..4d16b3bef5194 100644 --- a/compiler/rustc_smir/src/stable_mir/mir/mono.rs +++ b/compiler/rustc_smir/src/stable_mir/mir/mono.rs @@ -1,14 +1,15 @@ use std::fmt::{Debug, Formatter}; use std::io; +use rustc_smir::{IndexedVal, SmirError}; use serde::Serialize; use stable_mir::abi::FnAbi; use stable_mir::crate_def::CrateDef; use stable_mir::mir::Body; -use stable_mir::ty::{Allocation, ClosureDef, ClosureKind, FnDef, GenericArgs, IndexedVal, Ty}; +use stable_mir::ty::{Allocation, ClosureDef, ClosureKind, FnDef, GenericArgs, Ty}; use stable_mir::{CrateItem, DefId, Error, ItemKind, Opaque, Symbol, with}; -use crate::stable_mir; +use crate::{rustc_smir, stable_mir}; #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)] pub enum MonoItem { From 588ea908b217ea9464800590797bfc2a396e0d88 Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 5 May 2025 15:25:54 +0800 Subject: [PATCH 05/22] refactor: split `rustc_smir::alloc` into two parts The previous `rustc_smir::alloc` had many direct calls to rustc queries. This commit splits it into two parts: `rustc_smir::alloc` and `stable_mir::alloc`. Following the same pattern as `SmirCtxt` and `SmirInterface`, the `rustc_smir::alloc` handles all direct interactions with rustc queries and performs the actual memory allocations, while the `stable_mir::alloc` is responsible for constructing stable components. --- compiler/rustc_smir/src/rustc_smir/alloc.rs | 161 ++++++++------------ compiler/rustc_smir/src/rustc_smir/mod.rs | 2 +- compiler/rustc_smir/src/stable_mir/alloc.rs | 86 +++++++++++ compiler/rustc_smir/src/stable_mir/mod.rs | 1 + 4 files changed, 151 insertions(+), 99 deletions(-) create mode 100644 compiler/rustc_smir/src/stable_mir/alloc.rs diff --git a/compiler/rustc_smir/src/rustc_smir/alloc.rs b/compiler/rustc_smir/src/rustc_smir/alloc.rs index a6d31ac4e13dd..34692962de707 100644 --- a/compiler/rustc_smir/src/rustc_smir/alloc.rs +++ b/compiler/rustc_smir/src/rustc_smir/alloc.rs @@ -1,102 +1,74 @@ -use rustc_abi::{Align, Size}; -use rustc_middle::mir::ConstValue; -use rustc_middle::mir::interpret::{AllocInit, AllocRange, Pointer, alloc_range}; -use stable_mir::Error; -use stable_mir::mir::Mutability; -use stable_mir::ty::{Allocation, ProvenanceMap}; +//! Internal memory allocator implementation for StableMIR. +//! +//! This module handles all direct interactions with rustc queries and performs +//! the actual memory allocations. The stable interface in `stable_mir::alloc` +//! delegates all query-related operations to this implementation. -use crate::rustc_smir::{Stable, Tables}; -use crate::stable_mir; +use rustc_abi::{Size, TyAndLayout}; +use rustc_middle::mir::interpret::{ + AllocId, AllocInit, AllocRange, Allocation, ConstAllocation, Pointer, Scalar, alloc_range, +}; +use rustc_middle::ty::Ty; -/// Creates new empty `Allocation` from given `Align`. -fn new_empty_allocation(align: Align) -> Allocation { - Allocation { - bytes: Vec::new(), - provenance: ProvenanceMap { ptrs: Vec::new() }, - align: align.bytes(), - mutability: Mutability::Not, - } +use crate::rustc_smir::{Bridge, SmirError, Tables}; + +pub fn try_new_scalar<'tcx, B: Bridge>( + layout: TyAndLayout<'tcx, Ty<'tcx>>, + scalar: Scalar, + tables: &mut Tables<'tcx, B>, +) -> Result { + 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) + .map_err(|e| B::Error::from_internal(e))?; + + Ok(allocation) } -// We need this method instead of a Stable implementation -// because we need to get `Ty` of the const we are trying to create, to do that -// we need to have access to `ConstantKind` but we can't access that inside Stable impl. -#[allow(rustc::usage_of_qualified_ty)] -pub(crate) fn new_allocation<'tcx>( - ty: rustc_middle::ty::Ty<'tcx>, - const_value: ConstValue<'tcx>, - tables: &mut Tables<'tcx>, -) -> Allocation { - try_new_allocation(ty, const_value, tables) - .unwrap_or_else(|_| panic!("Failed to convert: {const_value:?} to {ty:?}")) +pub fn try_new_slice<'tcx, B: Bridge>( + layout: TyAndLayout<'tcx, Ty<'tcx>>, + data: ConstAllocation<'tcx>, + meta: u64, + tables: &mut Tables<'tcx, B>, +) -> Result { + let alloc_id = tables.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 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, + ) + .map_err(|e| B::Error::from_internal(e))?; + allocation + .write_scalar( + &tables.tcx, + alloc_range(tables.tcx.data_layout.pointer_size, scalar_meta.size()), + scalar_meta, + ) + .map_err(|e| B::Error::from_internal(e))?; + + Ok(allocation) } -#[allow(rustc::usage_of_qualified_ty)] -pub(crate) fn try_new_allocation<'tcx>( - ty: rustc_middle::ty::Ty<'tcx>, - const_value: ConstValue<'tcx>, - tables: &mut Tables<'tcx>, -) -> Result { - let layout = tables - .tcx - .layout_of(rustc_middle::ty::TypingEnv::fully_monomorphized().as_query_input(ty)) - .map_err(|e| e.stable(tables))?; - Ok(match const_value { - ConstValue::Scalar(scalar) => { - let size = scalar.size(); - let mut allocation = rustc_middle::mir::interpret::Allocation::new( - size, - layout.align.abi, - AllocInit::Uninit, - (), - ); - allocation - .write_scalar(&tables.tcx, alloc_range(Size::ZERO, size), scalar) - .map_err(|e| e.stable(tables))?; - allocation.stable(tables) - } - ConstValue::ZeroSized => new_empty_allocation(layout.align.abi), - ConstValue::Slice { data, meta } => { - let alloc_id = tables.tcx.reserve_and_set_memory_alloc(data); - let ptr = Pointer::new(alloc_id.into(), Size::ZERO); - let scalar_ptr = rustc_middle::mir::interpret::Scalar::from_pointer(ptr, &tables.tcx); - let scalar_meta = - rustc_middle::mir::interpret::Scalar::from_target_usize(meta, &tables.tcx); - let mut allocation = rustc_middle::mir::interpret::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, - ) - .map_err(|e| e.stable(tables))?; - allocation - .write_scalar( - &tables.tcx, - alloc_range(tables.tcx.data_layout.pointer_size, scalar_meta.size()), - scalar_meta, - ) - .map_err(|e| e.stable(tables))?; - allocation.stable(tables) - } - ConstValue::Indirect { alloc_id, offset } => { - let alloc = tables.tcx.global_alloc(alloc_id).unwrap_memory(); - allocation_filter(&alloc.0, alloc_range(offset, layout.size), tables) - } - }) +pub fn try_new_indirect<'tcx, B: Bridge>( + alloc_id: AllocId, + tables: &mut Tables<'tcx, B>, +) -> ConstAllocation<'tcx> { + let alloc = tables.tcx.global_alloc(alloc_id).unwrap_memory(); + + alloc } /// Creates an `Allocation` only from information within the `AllocRange`. -pub(super) fn allocation_filter<'tcx>( +pub fn allocation_filter( alloc: &rustc_middle::mir::interpret::Allocation, alloc_range: AllocRange, - tables: &mut Tables<'tcx>, -) -> Allocation { +) -> (Vec>, Vec<(usize, AllocId)>) { let mut bytes: Vec> = alloc .inspect_with_uninit_and_ptr_outside_interpreter( alloc_range.start.bytes_usize()..alloc_range.end().bytes_usize(), @@ -117,15 +89,8 @@ pub(super) fn allocation_filter<'tcx>( .iter() .filter(|a| a.0 >= alloc_range.start && a.0 <= alloc_range.end()) { - ptrs.push(( - offset.bytes_usize() - alloc_range.start.bytes_usize(), - tables.prov(prov.alloc_id()), - )); - } - Allocation { - bytes, - provenance: ProvenanceMap { ptrs }, - align: alloc.align.bytes(), - mutability: alloc.mutability.stable(tables), + ptrs.push((offset.bytes_usize() - alloc_range.start.bytes_usize(), prov.alloc_id())); } + + (bytes, ptrs) } diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs index 9ce5520ee8e40..03b3a93dc069c 100644 --- a/compiler/rustc_smir/src/rustc_smir/mod.rs +++ b/compiler/rustc_smir/src/rustc_smir/mod.rs @@ -20,7 +20,7 @@ use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE}; use crate::rustc_internal::IndexMap; -mod alloc; +pub mod alloc; mod builder; pub mod context; mod convert; diff --git a/compiler/rustc_smir/src/stable_mir/alloc.rs b/compiler/rustc_smir/src/stable_mir/alloc.rs new file mode 100644 index 0000000000000..4e6facac705e7 --- /dev/null +++ b/compiler/rustc_smir/src/stable_mir/alloc.rs @@ -0,0 +1,86 @@ +//! Memory allocation implementation for StableMIR. +//! +//! This module is responsible for constructing stable components. +//! All operations requiring rustc queries must be delegated +//! to `rustc_smir::alloc` to maintain stability guarantees. + +use rustc_abi::Align; +use rustc_middle::mir::ConstValue; +use rustc_middle::mir::interpret::AllocRange; +use rustc_smir::context::SmirCtxt; +use rustc_smir::{SmirError, Tables, alloc}; + +use super::Error; +use super::compiler_interface::BridgeTys; +use super::convert::Stable; +use super::mir::Mutability; +use super::ty::{Allocation, ProvenanceMap}; +use crate::rustc_smir; + +/// Creates new empty `Allocation` from given `Align`. +fn new_empty_allocation(align: Align) -> Allocation { + Allocation { + bytes: Vec::new(), + provenance: ProvenanceMap { ptrs: Vec::new() }, + align: align.bytes(), + mutability: Mutability::Not, + } +} + +// We need this method instead of a Stable implementation +// because we need to get `Ty` of the const we are trying to create, to do that +// we need to have access to `ConstantKind` but we can't access that inside Stable impl. +#[allow(rustc::usage_of_qualified_ty)] +pub(crate) fn new_allocation<'tcx>( + ty: rustc_middle::ty::Ty<'tcx>, + const_value: ConstValue<'tcx>, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, +) -> Allocation { + try_new_allocation(ty, const_value, tables, cx) + .unwrap_or_else(|_| panic!("Failed to convert: {const_value:?} to {ty:?}")) +} + +#[allow(rustc::usage_of_qualified_ty)] +pub(crate) fn try_new_allocation<'tcx>( + ty: rustc_middle::ty::Ty<'tcx>, + const_value: ConstValue<'tcx>, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, +) -> Result { + use rustc_smir::context::SmirTypingEnv; + let layout = cx + .layout_of(cx.fully_monomorphized().as_query_input(ty)) + .map_err(|e| Error::from_internal(e))?; + match const_value { + ConstValue::Scalar(scalar) => { + alloc::try_new_scalar(layout, scalar, tables).map(|alloc| alloc.stable(tables, cx)) + } + ConstValue::ZeroSized => Ok(new_empty_allocation(layout.align.abi)), + ConstValue::Slice { data, meta } => { + alloc::try_new_slice(layout, data, meta, tables).map(|alloc| alloc.stable(tables, cx)) + } + ConstValue::Indirect { alloc_id, offset } => { + let alloc = alloc::try_new_indirect(alloc_id, tables); + use rustc_smir::context::SmirAllocRange; + Ok(allocation_filter(&alloc.0, cx.alloc_range(offset, layout.size), tables, cx)) + } + } +} + +/// Creates an `Allocation` only from information within the `AllocRange`. +pub(super) fn allocation_filter<'tcx>( + alloc: &rustc_middle::mir::interpret::Allocation, + alloc_range: AllocRange, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, +) -> Allocation { + let (bytes, ptrs) = alloc::allocation_filter(alloc, alloc_range); + let ptrs = ptrs.iter().map(|(i, aid)| (*i, tables.prov(*aid))).collect(); + Allocation { + bytes, + provenance: ProvenanceMap { ptrs }, + align: alloc.align.bytes(), + mutability: alloc.mutability.stable(tables, cx), + } +} diff --git a/compiler/rustc_smir/src/stable_mir/mod.rs b/compiler/rustc_smir/src/stable_mir/mod.rs index 1c992ec5dbb7e..d3ef5f4001dc4 100644 --- a/compiler/rustc_smir/src/stable_mir/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/mod.rs @@ -40,6 +40,7 @@ use stable_mir::ty::{AssocItem, FnDef, ForeignModuleDef, ImplDef, Span, TraitDef use crate::{rustc_smir, stable_mir}; pub mod abi; +mod alloc; #[macro_use] pub mod crate_def; pub mod compiler_interface; From 73e358d3aa33859db68d52beace826355aaded1f Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 5 May 2025 15:31:34 +0800 Subject: [PATCH 06/22] refactor: rewrite the whole `rustc_smir::context` This commit removes the `Tables` field from `SmirCtxt`, since borrows of `tables` should only be managed by `SmirInterface`. This change prevents `SmirCtxt` from holding separate borrows and requires passing `tables` explicitly when needed. We use the `traits.rs` file to define traits that are used for encapsulating the associated functions in the rustc's internals. This is much easier to use and maintain than directly cramming everything into `SmirCtxt`. --- compiler/rustc_smir/src/rustc_smir/context.rs | 996 ------------------ .../src/rustc_smir/context/impls.rs | 790 ++++++++++++++ .../rustc_smir/src/rustc_smir/context/mod.rs | 79 ++ .../src/rustc_smir/context/traits.rs | 50 + 4 files changed, 919 insertions(+), 996 deletions(-) delete mode 100644 compiler/rustc_smir/src/rustc_smir/context.rs create mode 100644 compiler/rustc_smir/src/rustc_smir/context/impls.rs create mode 100644 compiler/rustc_smir/src/rustc_smir/context/mod.rs create mode 100644 compiler/rustc_smir/src/rustc_smir/context/traits.rs diff --git a/compiler/rustc_smir/src/rustc_smir/context.rs b/compiler/rustc_smir/src/rustc_smir/context.rs deleted file mode 100644 index baa4c0681e806..0000000000000 --- a/compiler/rustc_smir/src/rustc_smir/context.rs +++ /dev/null @@ -1,996 +0,0 @@ -//! Implementation of StableMIR Context. - -#![allow(rustc::usage_of_qualified_ty)] - -use std::cell::RefCell; -use std::iter; - -use rustc_abi::HasDataLayout; -use rustc_hir::{Attribute, LangItem}; -use rustc_middle::ty::layout::{ - FnAbiOf, FnAbiOfHelpers, HasTyCtxt, HasTypingEnv, LayoutOf, LayoutOfHelpers, -}; -use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths}; -use rustc_middle::ty::{ - CoroutineArgsExt, GenericPredicates, Instance, List, ScalarInt, TyCtxt, TypeVisitableExt, - ValTree, -}; -use rustc_middle::{mir, ty}; -use rustc_span::def_id::LOCAL_CRATE; -use stable_mir::abi::{FnAbi, Layout, LayoutShape, ReprOptions}; -use stable_mir::mir::alloc::GlobalAlloc; -use stable_mir::mir::mono::{InstanceDef, StaticDef}; -use stable_mir::mir::{BinOp, Body, Place, UnOp}; -use stable_mir::target::{MachineInfo, MachineSize}; -use stable_mir::ty::{ - AdtDef, AdtKind, Allocation, ClosureDef, ClosureKind, CoroutineDef, Discr, FieldDef, FnDef, - ForeignDef, ForeignItemKind, GenericArgs, IntrinsicDef, LineInfo, MirConst, PolyFnSig, RigidTy, - Span, Ty, TyConst, TyKind, UintTy, VariantDef, VariantIdx, -}; -use stable_mir::{Crate, CrateDef, CrateItem, CrateNum, DefId, Error, Filename, ItemKind, Symbol}; - -use crate::rustc_internal::RustcInternal; -use crate::rustc_smir::builder::BodyBuilder; -use crate::rustc_smir::{Stable, Tables, alloc, filter_def_ids, new_item_kind, smir_crate}; -use crate::stable_mir; - -/// Provides direct access to rustc's internal queries. -/// -/// The [`crate::stable_mir::compiler_interface::SmirInterface`] must go through -/// this context to obtain rustc-level information. -pub struct SmirCtxt<'tcx>(pub RefCell>); - -impl<'tcx> SmirCtxt<'tcx> { - pub fn target_info(&self) -> MachineInfo { - let mut tables = self.0.borrow_mut(); - MachineInfo { - endian: tables.tcx.data_layout.endian.stable(&mut *tables), - pointer_width: MachineSize::from_bits( - tables.tcx.data_layout.pointer_size.bits().try_into().unwrap(), - ), - } - } - - pub fn entry_fn(&self) -> Option { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - Some(tables.crate_item(tcx.entry_fn(())?.0)) - } - - /// Retrieve all items of the local crate that have a MIR associated with them. - pub fn all_local_items(&self) -> stable_mir::CrateItems { - let mut tables = self.0.borrow_mut(); - tables.tcx.mir_keys(()).iter().map(|item| tables.crate_item(item.to_def_id())).collect() - } - - /// Retrieve the body of a function. - /// This function will panic if the body is not available. - pub fn mir_body(&self, item: stable_mir::DefId) -> stable_mir::mir::Body { - let mut tables = self.0.borrow_mut(); - let def_id = tables[item]; - tables.tcx.instance_mir(rustc_middle::ty::InstanceKind::Item(def_id)).stable(&mut tables) - } - - /// Check whether the body of a function is available. - pub fn has_body(&self, def: DefId) -> bool { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let def_id = def.internal(&mut *tables, tcx); - tables.item_has_body(def_id) - } - - pub fn foreign_modules(&self, crate_num: CrateNum) -> Vec { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - tcx.foreign_modules(crate_num.internal(&mut *tables, tcx)) - .keys() - .map(|mod_def_id| tables.foreign_module_def(*mod_def_id)) - .collect() - } - - /// Retrieve all functions defined in this crate. - pub fn crate_functions(&self, crate_num: CrateNum) -> Vec { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let krate = crate_num.internal(&mut *tables, tcx); - filter_def_ids(tcx, krate, |def_id| tables.to_fn_def(def_id)) - } - - /// Retrieve all static items defined in this crate. - pub fn crate_statics(&self, crate_num: CrateNum) -> Vec { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let krate = crate_num.internal(&mut *tables, tcx); - filter_def_ids(tcx, krate, |def_id| tables.to_static(def_id)) - } - - pub fn foreign_module( - &self, - mod_def: stable_mir::ty::ForeignModuleDef, - ) -> stable_mir::ty::ForeignModule { - let mut tables = self.0.borrow_mut(); - let def_id = tables[mod_def.def_id()]; - let mod_def = tables.tcx.foreign_modules(def_id.krate).get(&def_id).unwrap(); - mod_def.stable(&mut *tables) - } - - pub fn foreign_items(&self, mod_def: stable_mir::ty::ForeignModuleDef) -> Vec { - let mut tables = self.0.borrow_mut(); - let def_id = tables[mod_def.def_id()]; - tables - .tcx - .foreign_modules(def_id.krate) - .get(&def_id) - .unwrap() - .foreign_items - .iter() - .map(|item_def| tables.foreign_def(*item_def)) - .collect() - } - - pub fn all_trait_decls(&self) -> stable_mir::TraitDecls { - let mut tables = self.0.borrow_mut(); - tables.tcx.all_traits().map(|trait_def_id| tables.trait_def(trait_def_id)).collect() - } - - pub fn trait_decls(&self, crate_num: CrateNum) -> stable_mir::TraitDecls { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - tcx.traits(crate_num.internal(&mut *tables, tcx)) - .iter() - .map(|trait_def_id| tables.trait_def(*trait_def_id)) - .collect() - } - - pub fn trait_decl(&self, trait_def: &stable_mir::ty::TraitDef) -> stable_mir::ty::TraitDecl { - let mut tables = self.0.borrow_mut(); - let def_id = tables[trait_def.0]; - let trait_def = tables.tcx.trait_def(def_id); - trait_def.stable(&mut *tables) - } - - pub fn all_trait_impls(&self) -> stable_mir::ImplTraitDecls { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - iter::once(LOCAL_CRATE) - .chain(tables.tcx.crates(()).iter().copied()) - .flat_map(|cnum| tcx.trait_impls_in_crate(cnum).iter()) - .map(|impl_def_id| tables.impl_def(*impl_def_id)) - .collect() - } - - pub fn trait_impls(&self, crate_num: CrateNum) -> stable_mir::ImplTraitDecls { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - tcx.trait_impls_in_crate(crate_num.internal(&mut *tables, tcx)) - .iter() - .map(|impl_def_id| tables.impl_def(*impl_def_id)) - .collect() - } - - pub fn trait_impl(&self, impl_def: &stable_mir::ty::ImplDef) -> stable_mir::ty::ImplTrait { - let mut tables = self.0.borrow_mut(); - let def_id = tables[impl_def.0]; - let impl_trait = tables.tcx.impl_trait_ref(def_id).unwrap(); - impl_trait.stable(&mut *tables) - } - - pub fn generics_of(&self, def_id: stable_mir::DefId) -> stable_mir::ty::Generics { - let mut tables = self.0.borrow_mut(); - let def_id = tables[def_id]; - let generics = tables.tcx.generics_of(def_id); - generics.stable(&mut *tables) - } - - pub fn predicates_of(&self, def_id: stable_mir::DefId) -> stable_mir::ty::GenericPredicates { - let mut tables = self.0.borrow_mut(); - let def_id = tables[def_id]; - let GenericPredicates { parent, predicates } = tables.tcx.predicates_of(def_id); - stable_mir::ty::GenericPredicates { - parent: parent.map(|did| tables.trait_def(did)), - predicates: predicates - .iter() - .map(|(clause, span)| { - ( - clause.as_predicate().kind().skip_binder().stable(&mut *tables), - span.stable(&mut *tables), - ) - }) - .collect(), - } - } - - pub fn explicit_predicates_of( - &self, - def_id: stable_mir::DefId, - ) -> stable_mir::ty::GenericPredicates { - let mut tables = self.0.borrow_mut(); - let def_id = tables[def_id]; - let GenericPredicates { parent, predicates } = tables.tcx.explicit_predicates_of(def_id); - stable_mir::ty::GenericPredicates { - parent: parent.map(|did| tables.trait_def(did)), - predicates: predicates - .iter() - .map(|(clause, span)| { - ( - clause.as_predicate().kind().skip_binder().stable(&mut *tables), - span.stable(&mut *tables), - ) - }) - .collect(), - } - } - - /// Get information about the local crate. - pub fn local_crate(&self) -> stable_mir::Crate { - let tables = self.0.borrow(); - smir_crate(tables.tcx, LOCAL_CRATE) - } - - /// Retrieve a list of all external crates. - pub fn external_crates(&self) -> Vec { - let tables = self.0.borrow(); - tables.tcx.crates(()).iter().map(|crate_num| smir_crate(tables.tcx, *crate_num)).collect() - } - - /// Find a crate with the given name. - pub fn find_crates(&self, name: &str) -> Vec { - let tables = self.0.borrow(); - let crates: Vec = [LOCAL_CRATE] - .iter() - .chain(tables.tcx.crates(()).iter()) - .filter_map(|crate_num| { - let crate_name = tables.tcx.crate_name(*crate_num).to_string(); - (name == crate_name).then(|| smir_crate(tables.tcx, *crate_num)) - }) - .collect(); - crates - } - - /// Returns the name of given `DefId`. - pub fn def_name(&self, def_id: stable_mir::DefId, trimmed: bool) -> Symbol { - let tables = self.0.borrow(); - if trimmed { - with_forced_trimmed_paths!(tables.tcx.def_path_str(tables[def_id])) - } else { - with_no_trimmed_paths!(tables.tcx.def_path_str(tables[def_id])) - } - } - - /// Return registered tool attributes with the given attribute name. - /// - /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool - /// attributes will simply return an empty list. - /// - /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`. - /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`. - pub fn tool_attrs( - &self, - def_id: stable_mir::DefId, - attr: &[stable_mir::Symbol], - ) -> Vec { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let did = tables[def_id]; - let attr_name: Vec<_> = attr.iter().map(|seg| rustc_span::Symbol::intern(&seg)).collect(); - tcx.get_attrs_by_path(did, &attr_name) - .filter_map(|attribute| { - if let Attribute::Unparsed(u) = attribute { - let attr_str = rustc_hir_pretty::attribute_to_string(&tcx, attribute); - Some(stable_mir::crate_def::Attribute::new( - attr_str, - u.span.stable(&mut *tables), - )) - } else { - None - } - }) - .collect() - } - - /// Get all tool attributes of a definition. - pub fn all_tool_attrs( - &self, - def_id: stable_mir::DefId, - ) -> Vec { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let did = tables[def_id]; - let attrs_iter = if let Some(did) = did.as_local() { - tcx.hir_attrs(tcx.local_def_id_to_hir_id(did)).iter() - } else { - tcx.attrs_for_def(did).iter() - }; - attrs_iter - .filter_map(|attribute| { - if let Attribute::Unparsed(u) = attribute { - let attr_str = rustc_hir_pretty::attribute_to_string(&tcx, attribute); - Some(stable_mir::crate_def::Attribute::new( - attr_str, - u.span.stable(&mut *tables), - )) - } else { - None - } - }) - .collect() - } - - /// Returns printable, human readable form of `Span`. - pub fn span_to_string(&self, span: stable_mir::ty::Span) -> String { - let tables = self.0.borrow(); - tables.tcx.sess.source_map().span_to_diagnostic_string(tables[span]) - } - - /// Return filename from given `Span`, for diagnostic purposes. - pub fn get_filename(&self, span: &Span) -> Filename { - let tables = self.0.borrow(); - tables - .tcx - .sess - .source_map() - .span_to_filename(tables[*span]) - .display(rustc_span::FileNameDisplayPreference::Local) - .to_string() - } - - /// Return lines corresponding to this `Span`. - pub fn get_lines(&self, span: &Span) -> LineInfo { - let tables = self.0.borrow(); - let lines = &tables.tcx.sess.source_map().span_to_location_info(tables[*span]); - LineInfo { start_line: lines.1, start_col: lines.2, end_line: lines.3, end_col: lines.4 } - } - - /// Returns the `kind` of given `DefId`. - pub fn item_kind(&self, item: CrateItem) -> ItemKind { - let tables = self.0.borrow(); - new_item_kind(tables.tcx.def_kind(tables[item.0])) - } - - /// Returns whether this is a foreign item. - pub fn is_foreign_item(&self, item: DefId) -> bool { - let tables = self.0.borrow(); - tables.tcx.is_foreign_item(tables[item]) - } - - /// Returns the kind of a given foreign item. - pub fn foreign_item_kind(&self, def: ForeignDef) -> ForeignItemKind { - let mut tables = self.0.borrow_mut(); - let def_id = tables[def.def_id()]; - let tcx = tables.tcx; - use rustc_hir::def::DefKind; - match tcx.def_kind(def_id) { - DefKind::Fn => ForeignItemKind::Fn(tables.fn_def(def_id)), - DefKind::Static { .. } => ForeignItemKind::Static(tables.static_def(def_id)), - DefKind::ForeignTy => ForeignItemKind::Type( - tables.intern_ty(rustc_middle::ty::Ty::new_foreign(tcx, def_id)), - ), - def_kind => unreachable!("Unexpected kind for a foreign item: {:?}", def_kind), - } - } - - /// Returns the kind of a given algebraic data type. - pub fn adt_kind(&self, def: AdtDef) -> AdtKind { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - def.internal(&mut *tables, tcx).adt_kind().stable(&mut *tables) - } - - /// Returns if the ADT is a box. - pub fn adt_is_box(&self, def: AdtDef) -> bool { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - def.internal(&mut *tables, tcx).is_box() - } - - /// Returns whether this ADT is simd. - pub fn adt_is_simd(&self, def: AdtDef) -> bool { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - def.internal(&mut *tables, tcx).repr().simd() - } - - /// Returns whether this definition is a C string. - pub fn adt_is_cstr(&self, def: AdtDef) -> bool { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let def_id = def.0.internal(&mut *tables, tcx); - tables.tcx.is_lang_item(def_id, LangItem::CStr) - } - - /// Returns the representation options for this ADT - pub fn adt_repr(&self, def: AdtDef) -> ReprOptions { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - def.internal(&mut *tables, tcx).repr().stable(&mut *tables) - } - - /// Retrieve the function signature for the given generic arguments. - pub fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - 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) - } - - /// Retrieve the intrinsic definition if the item corresponds one. - pub fn intrinsic(&self, def: DefId) -> Option { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let def_id = def.internal(&mut *tables, tcx); - let intrinsic = tcx.intrinsic_raw(def_id); - intrinsic.map(|_| IntrinsicDef(def)) - } - - /// Retrieve the plain function name of an intrinsic. - pub fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let def_id = def.0.internal(&mut *tables, tcx); - tcx.intrinsic(def_id).unwrap().name.to_string() - } - - /// Retrieve the closure signature for the given generic arguments. - pub fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let args_ref = args.internal(&mut *tables, tcx); - let sig = args_ref.as_closure().sig(); - sig.stable(&mut *tables) - } - - /// The number of variants in this ADT. - pub fn adt_variants_len(&self, def: AdtDef) -> usize { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - def.internal(&mut *tables, tcx).variants().len() - } - - /// Discriminant for a given variant index of AdtDef - pub fn adt_discr_for_variant(&self, adt: AdtDef, variant: VariantIdx) -> Discr { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let adt = adt.internal(&mut *tables, tcx); - let variant = variant.internal(&mut *tables, tcx); - adt.discriminant_for_variant(tcx, variant).stable(&mut *tables) - } - - /// Discriminant for a given variand index and args of a coroutine - pub fn coroutine_discr_for_variant( - &self, - coroutine: CoroutineDef, - args: &GenericArgs, - variant: VariantIdx, - ) -> Discr { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let coroutine = coroutine.def_id().internal(&mut *tables, tcx); - let args = args.internal(&mut *tables, tcx); - let variant = variant.internal(&mut *tables, tcx); - args.as_coroutine().discriminant_for_variant(coroutine, tcx, variant).stable(&mut *tables) - } - - /// The name of a variant. - pub fn variant_name(&self, def: VariantDef) -> Symbol { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - def.internal(&mut *tables, tcx).name.to_string() - } - - pub fn variant_fields(&self, def: VariantDef) -> Vec { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - def.internal(&mut *tables, tcx).fields.iter().map(|f| f.stable(&mut *tables)).collect() - } - - /// Evaluate constant as a target usize. - pub fn eval_target_usize(&self, cnst: &MirConst) -> Result { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let mir_const = cnst.internal(&mut *tables, tcx); - mir_const - .try_eval_target_usize(tables.tcx, ty::TypingEnv::fully_monomorphized()) - .ok_or_else(|| Error::new(format!("Const `{cnst:?}` cannot be encoded as u64"))) - } - pub fn eval_target_usize_ty(&self, cnst: &TyConst) -> Result { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let mir_const = cnst.internal(&mut *tables, tcx); - mir_const - .try_to_target_usize(tables.tcx) - .ok_or_else(|| Error::new(format!("Const `{cnst:?}` cannot be encoded as u64"))) - } - - /// Create a new zero-sized constant. - pub fn try_new_const_zst(&self, ty: Ty) -> Result { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let ty_internal = ty.internal(&mut *tables, tcx); - let size = tables - .tcx - .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty_internal)) - .map_err(|err| { - Error::new(format!( - "Cannot create a zero-sized constant for type `{ty_internal}`: {err}" - )) - })? - .size; - if size.bytes() != 0 { - return Err(Error::new(format!( - "Cannot create a zero-sized constant for type `{ty_internal}`: \ - Type `{ty_internal}` has {} bytes", - size.bytes() - ))); - } - - Ok(mir::Const::Ty(ty_internal, ty::Const::zero_sized(tables.tcx, ty_internal)) - .stable(&mut *tables)) - } - - /// Create a new constant that represents the given string value. - pub fn new_const_str(&self, value: &str) -> MirConst { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let ty = ty::Ty::new_static_str(tcx); - let bytes = value.as_bytes(); - let valtree = ty::ValTree::from_raw_bytes(tcx, bytes); - let cv = ty::Value { ty, valtree }; - let val = tcx.valtree_to_const_val(cv); - mir::Const::from_value(val, ty).stable(&mut tables) - } - - /// Create a new constant that represents the given boolean value. - pub fn new_const_bool(&self, value: bool) -> MirConst { - let mut tables = self.0.borrow_mut(); - mir::Const::from_bool(tables.tcx, value).stable(&mut tables) - } - - /// Create a new constant that represents the given value. - pub fn try_new_const_uint(&self, value: u128, uint_ty: UintTy) -> Result { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let ty = ty::Ty::new_uint(tcx, uint_ty.internal(&mut *tables, tcx)); - let size = tables - .tcx - .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty)) - .unwrap() - .size; - let scalar = ScalarInt::try_from_uint(value, size).ok_or_else(|| { - Error::new(format!("Value overflow: cannot convert `{value}` to `{ty}`.")) - })?; - Ok(mir::Const::from_scalar(tcx, mir::interpret::Scalar::Int(scalar), ty) - .stable(&mut tables)) - } - pub fn try_new_ty_const_uint( - &self, - value: u128, - uint_ty: UintTy, - ) -> Result { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let ty = ty::Ty::new_uint(tcx, uint_ty.internal(&mut *tables, tcx)); - let size = tables - .tcx - .layout_of(ty::TypingEnv::fully_monomorphized().as_query_input(ty)) - .unwrap() - .size; - - // We don't use Const::from_bits since it doesn't have any error checking. - let scalar = ScalarInt::try_from_uint(value, size).ok_or_else(|| { - Error::new(format!("Value overflow: cannot convert `{value}` to `{ty}`.")) - })?; - Ok(ty::Const::new_value(tcx, ValTree::from_scalar_int(tcx, scalar), ty) - .stable(&mut *tables)) - } - - /// Create a new type from the given kind. - pub fn new_rigid_ty(&self, kind: RigidTy) -> stable_mir::ty::Ty { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let internal_kind = kind.internal(&mut *tables, tcx); - tables.tcx.mk_ty_from_kind(internal_kind).stable(&mut *tables) - } - - /// Create a new box type, `Box`, for the given inner type `T`. - pub fn new_box_ty(&self, ty: stable_mir::ty::Ty) -> stable_mir::ty::Ty { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let inner = ty.internal(&mut *tables, tcx); - ty::Ty::new_box(tables.tcx, inner).stable(&mut *tables) - } - - /// Returns the type of given crate item. - pub fn def_ty(&self, item: stable_mir::DefId) -> stable_mir::ty::Ty { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - tcx.type_of(item.internal(&mut *tables, tcx)).instantiate_identity().stable(&mut *tables) - } - - /// Returns the type of given definition instantiated with the given arguments. - pub fn def_ty_with_args( - &self, - item: stable_mir::DefId, - args: &GenericArgs, - ) -> stable_mir::ty::Ty { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let args = args.internal(&mut *tables, tcx); - let def_ty = tables.tcx.type_of(item.internal(&mut *tables, tcx)); - tables - .tcx - .instantiate_and_normalize_erasing_regions( - args, - ty::TypingEnv::fully_monomorphized(), - def_ty, - ) - .stable(&mut *tables) - } - - /// Returns literal value of a const as a string. - pub fn mir_const_pretty(&self, cnst: &stable_mir::ty::MirConst) -> String { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - cnst.internal(&mut *tables, tcx).to_string() - } - - /// `Span` of an item. - pub fn span_of_an_item(&self, def_id: stable_mir::DefId) -> Span { - let mut tables = self.0.borrow_mut(); - tables.tcx.def_span(tables[def_id]).stable(&mut *tables) - } - - /// Obtain the representation of a type. - pub fn ty_pretty(&self, ty: stable_mir::ty::Ty) -> String { - let tables = self.0.borrow_mut(); - tables.types[ty].to_string() - } - - /// Obtain the representation of a type. - pub fn ty_kind(&self, ty: stable_mir::ty::Ty) -> TyKind { - let mut tables = self.0.borrow_mut(); - tables.types[ty].kind().stable(&mut *tables) - } - - pub fn ty_const_pretty(&self, ct: stable_mir::ty::TyConstId) -> String { - let tables = self.0.borrow_mut(); - tables.ty_consts[ct].to_string() - } - - /// Get the discriminant Ty for this Ty if there's one. - pub fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> stable_mir::ty::Ty { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let internal_kind = ty.internal(&mut *tables, tcx); - let internal_ty = tables.tcx.mk_ty_from_kind(internal_kind); - internal_ty.discriminant_ty(tables.tcx).stable(&mut *tables) - } - - /// Get the body of an Instance which is already monomorphized. - pub fn instance_body(&self, def: InstanceDef) -> Option { - let mut tables = self.0.borrow_mut(); - let instance = tables.instances[def]; - tables - .instance_has_body(instance) - .then(|| BodyBuilder::new(tables.tcx, instance).build(&mut *tables)) - } - - /// Get the instance type with generic instantiations applied and lifetimes erased. - pub fn instance_ty(&self, def: InstanceDef) -> stable_mir::ty::Ty { - let mut tables = self.0.borrow_mut(); - let instance = tables.instances[def]; - assert!(!instance.has_non_region_param(), "{instance:?} needs further instantiation"); - instance.ty(tables.tcx, ty::TypingEnv::fully_monomorphized()).stable(&mut *tables) - } - - /// Get the instantiation types. - pub fn instance_args(&self, def: InstanceDef) -> GenericArgs { - let mut tables = self.0.borrow_mut(); - let instance = tables.instances[def]; - instance.args.stable(&mut *tables) - } - - /// Get an instance ABI. - pub fn instance_abi(&self, def: InstanceDef) -> Result { - let mut tables = self.0.borrow_mut(); - let instance = tables.instances[def]; - Ok(tables.fn_abi_of_instance(instance, List::empty())?.stable(&mut *tables)) - } - - /// Get the ABI of a function pointer. - pub fn fn_ptr_abi(&self, fn_ptr: PolyFnSig) -> Result { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let sig = fn_ptr.internal(&mut *tables, tcx); - Ok(tables.fn_abi_of_fn_ptr(sig, List::empty())?.stable(&mut *tables)) - } - - /// Get the instance. - pub fn instance_def_id(&self, def: InstanceDef) -> stable_mir::DefId { - let mut tables = self.0.borrow_mut(); - let def_id = tables.instances[def].def_id(); - tables.create_def_id(def_id) - } - - /// Get the instance mangled name. - pub fn instance_mangled_name(&self, instance: InstanceDef) -> Symbol { - let tables = self.0.borrow_mut(); - let instance = tables.instances[instance]; - tables.tcx.symbol_name(instance).name.to_string() - } - - /// Check if this is an empty DropGlue shim. - pub fn is_empty_drop_shim(&self, def: InstanceDef) -> bool { - let tables = self.0.borrow_mut(); - let instance = tables.instances[def]; - matches!(instance.def, ty::InstanceKind::DropGlue(_, None)) - } - - /// Convert a non-generic crate item into an instance. - /// This function will panic if the item is generic. - pub fn mono_instance(&self, def_id: stable_mir::DefId) -> stable_mir::mir::mono::Instance { - let mut tables = self.0.borrow_mut(); - let def_id = tables[def_id]; - Instance::mono(tables.tcx, def_id).stable(&mut *tables) - } - - /// Item requires monomorphization. - pub fn requires_monomorphization(&self, def_id: stable_mir::DefId) -> bool { - let tables = self.0.borrow(); - let def_id = tables[def_id]; - let generics = tables.tcx.generics_of(def_id); - let result = generics.requires_monomorphization(tables.tcx); - result - } - - /// Resolve an instance from the given function definition and generic arguments. - pub fn resolve_instance( - &self, - def: stable_mir::ty::FnDef, - args: &stable_mir::ty::GenericArgs, - ) -> Option { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let def_id = def.0.internal(&mut *tables, tcx); - let args_ref = args.internal(&mut *tables, tcx); - match Instance::try_resolve( - tables.tcx, - ty::TypingEnv::fully_monomorphized(), - def_id, - args_ref, - ) { - Ok(Some(instance)) => Some(instance.stable(&mut *tables)), - Ok(None) | Err(_) => None, - } - } - - /// Resolve an instance for drop_in_place for the given type. - pub fn resolve_drop_in_place(&self, ty: stable_mir::ty::Ty) -> stable_mir::mir::mono::Instance { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let internal_ty = ty.internal(&mut *tables, tcx); - let instance = Instance::resolve_drop_in_place(tables.tcx, internal_ty); - instance.stable(&mut *tables) - } - - /// Resolve instance for a function pointer. - pub fn resolve_for_fn_ptr( - &self, - def: FnDef, - args: &GenericArgs, - ) -> Option { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let def_id = def.0.internal(&mut *tables, tcx); - let args_ref = args.internal(&mut *tables, tcx); - Instance::resolve_for_fn_ptr( - tables.tcx, - ty::TypingEnv::fully_monomorphized(), - def_id, - args_ref, - ) - .stable(&mut *tables) - } - - /// Resolve instance for a closure with the requested type. - pub fn resolve_closure( - &self, - def: ClosureDef, - args: &GenericArgs, - kind: ClosureKind, - ) -> Option { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let def_id = def.0.internal(&mut *tables, tcx); - let args_ref = args.internal(&mut *tables, tcx); - let closure_kind = kind.internal(&mut *tables, tcx); - Some( - Instance::resolve_closure(tables.tcx, def_id, args_ref, closure_kind) - .stable(&mut *tables), - ) - } - - /// Try to evaluate an instance into a constant. - pub fn eval_instance(&self, def: InstanceDef, const_ty: Ty) -> Result { - let mut tables = self.0.borrow_mut(); - let instance = tables.instances[def]; - let tcx = tables.tcx; - let result = tcx.const_eval_instance( - ty::TypingEnv::fully_monomorphized(), - instance, - tcx.def_span(instance.def_id()), - ); - result - .map(|const_val| { - alloc::try_new_allocation( - const_ty.internal(&mut *tables, tcx), - const_val, - &mut *tables, - ) - }) - .map_err(|e| e.stable(&mut *tables))? - } - - /// Evaluate a static's initializer. - pub fn eval_static_initializer(&self, def: StaticDef) -> Result { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let def_id = def.0.internal(&mut *tables, tcx); - tables.tcx.eval_static_initializer(def_id).stable(&mut *tables) - } - - /// Retrieve global allocation for the given allocation ID. - pub fn global_alloc(&self, alloc: stable_mir::mir::alloc::AllocId) -> GlobalAlloc { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let alloc_id = alloc.internal(&mut *tables, tcx); - tables.tcx.global_alloc(alloc_id).stable(&mut *tables) - } - - /// Retrieve the id for the virtual table. - pub fn vtable_allocation( - &self, - global_alloc: &GlobalAlloc, - ) -> Option { - let mut tables = self.0.borrow_mut(); - let GlobalAlloc::VTable(ty, trait_ref) = global_alloc else { - return None; - }; - let tcx = tables.tcx; - let alloc_id = tables.tcx.vtable_allocation(( - ty.internal(&mut *tables, tcx), - trait_ref - .internal(&mut *tables, tcx) - .map(|principal| tcx.instantiate_bound_regions_with_erased(principal)), - )); - Some(alloc_id.stable(&mut *tables)) - } - - pub fn krate(&self, def_id: stable_mir::DefId) -> Crate { - let tables = self.0.borrow(); - smir_crate(tables.tcx, tables[def_id].krate) - } - - /// Retrieve the instance name for diagnostic messages. - /// - /// This will return the specialized name, e.g., `Vec::new`. - pub fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol { - let tables = self.0.borrow_mut(); - let instance = tables.instances[def]; - if trimmed { - with_forced_trimmed_paths!( - tables.tcx.def_path_str_with_args(instance.def_id(), instance.args) - ) - } else { - with_no_trimmed_paths!( - tables.tcx.def_path_str_with_args(instance.def_id(), instance.args) - ) - } - } - - /// Get the layout of a type. - pub fn ty_layout(&self, ty: Ty) -> Result { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let ty = ty.internal(&mut *tables, tcx); - let layout = tables.layout_of(ty)?.layout; - Ok(layout.stable(&mut *tables)) - } - - /// Get the layout shape. - pub fn layout_shape(&self, id: Layout) -> LayoutShape { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - id.internal(&mut *tables, tcx).0.stable(&mut *tables) - } - - /// Get a debug string representation of a place. - pub fn place_pretty(&self, place: &Place) -> String { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - format!("{:?}", place.internal(&mut *tables, tcx)) - } - - /// Get the resulting type of binary operation. - pub fn binop_ty(&self, bin_op: BinOp, rhs: Ty, lhs: Ty) -> Ty { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let rhs_internal = rhs.internal(&mut *tables, tcx); - let lhs_internal = lhs.internal(&mut *tables, tcx); - let ty = bin_op.internal(&mut *tables, tcx).ty(tcx, rhs_internal, lhs_internal); - ty.stable(&mut *tables) - } - - /// Get the resulting type of unary operation. - pub fn unop_ty(&self, un_op: UnOp, arg: Ty) -> Ty { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let arg_internal = arg.internal(&mut *tables, tcx); - let ty = un_op.internal(&mut *tables, tcx).ty(tcx, arg_internal); - ty.stable(&mut *tables) - } - - /// Get all associated items of a definition. - pub fn associated_items(&self, def_id: stable_mir::DefId) -> stable_mir::AssocItems { - let mut tables = self.0.borrow_mut(); - let tcx = tables.tcx; - let def_id = tables[def_id]; - let assoc_items = if tcx.is_trait_alias(def_id) { - Vec::new() - } else { - tcx.associated_item_def_ids(def_id) - .iter() - .map(|did| tcx.associated_item(*did).stable(&mut *tables)) - .collect() - }; - assoc_items - } -} - -/// Implement error handling for extracting function ABI information. -impl<'tcx> FnAbiOfHelpers<'tcx> for Tables<'tcx> { - type FnAbiOfResult = Result<&'tcx rustc_target::callconv::FnAbi<'tcx, ty::Ty<'tcx>>, Error>; - - #[inline] - fn handle_fn_abi_err( - &self, - err: ty::layout::FnAbiError<'tcx>, - _span: rustc_span::Span, - fn_abi_request: ty::layout::FnAbiRequest<'tcx>, - ) -> Error { - Error::new(format!("Failed to get ABI for `{fn_abi_request:?}`: {err:?}")) - } -} - -impl<'tcx> LayoutOfHelpers<'tcx> for Tables<'tcx> { - type LayoutOfResult = Result, Error>; - - #[inline] - fn handle_layout_err( - &self, - err: ty::layout::LayoutError<'tcx>, - _span: rustc_span::Span, - ty: ty::Ty<'tcx>, - ) -> Error { - Error::new(format!("Failed to get layout for `{ty}`: {err}")) - } -} - -impl<'tcx> HasTypingEnv<'tcx> for Tables<'tcx> { - fn typing_env(&self) -> ty::TypingEnv<'tcx> { - ty::TypingEnv::fully_monomorphized() - } -} - -impl<'tcx> HasTyCtxt<'tcx> for Tables<'tcx> { - fn tcx(&self) -> TyCtxt<'tcx> { - self.tcx - } -} - -impl<'tcx> HasDataLayout for Tables<'tcx> { - fn data_layout(&self) -> &rustc_abi::TargetDataLayout { - self.tcx.data_layout() - } -} diff --git a/compiler/rustc_smir/src/rustc_smir/context/impls.rs b/compiler/rustc_smir/src/rustc_smir/context/impls.rs new file mode 100644 index 0000000000000..3151390886231 --- /dev/null +++ b/compiler/rustc_smir/src/rustc_smir/context/impls.rs @@ -0,0 +1,790 @@ +//! Implementation of StableMIR Context. + +#![allow(rustc::usage_of_qualified_ty)] + +use std::iter; + +use rustc_abi::{Endian, Layout}; +use rustc_hir::def::DefKind; +use rustc_hir::{Attribute, LangItem}; +use rustc_middle::infer::canonical::ir::{ + Binder, EarlyBinder, ExistentialTraitRef, FnSig, TraitRef, +}; +use rustc_middle::mir::interpret::{AllocId, ConstAllocation, ErrorHandled, GlobalAlloc, Scalar}; +use rustc_middle::mir::{BinOp, Body, Const as MirConst, ConstValue, UnOp}; +use rustc_middle::ty::layout::{FnAbiOf, LayoutOf}; +use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths}; +use rustc_middle::ty::{ + AdtDef, AdtKind, AssocItem, ClosureKind, GenericArgsRef, GenericPredicates, Instance, + InstanceKind, IntrinsicDef, List, PolyFnSig, ScalarInt, TraitDef, Ty, TyCtxt, TyKind, + TypeVisitableExt, UintTy, ValTree, VariantDef, +}; +use rustc_middle::{mir, ty}; +use rustc_session::cstore::ForeignModule; +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 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) + } +} + +impl<'tcx, B: Bridge> SmirTypingEnv<'tcx> for SmirCtxt<'tcx, B> { + fn fully_monomorphized(&self) -> ty::TypingEnv<'tcx> { + ty::TypingEnv::fully_monomorphized() + } +} + +impl<'tcx, B: Bridge> SmirAllocRange<'tcx> for SmirCtxt<'tcx, B> { + fn alloc_range( + &self, + offset: rustc_abi::Size, + size: rustc_abi::Size, + ) -> mir::interpret::AllocRange { + rustc_middle::mir::interpret::alloc_range(offset, size) + } +} + +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>>(&self, value: T) -> Option { + self.tcx.lift(value) + } + + pub fn mk_args_from_iter(&self, iter: I) -> T::Output + where + I: Iterator, + T: ty::CollectAndApply, 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> { + self.tcx.mk_poly_existential_predicates(eps) + } + + pub fn mk_type_list(&self, v: &[Ty<'tcx>]) -> &'tcx List> { + self.tcx.mk_type_list(v) + } + + pub fn mk_bound_variable_kinds_from_iter(&self, iter: I) -> T::Output + where + I: Iterator, + T: ty::CollectAndApply>, + { + self.tcx.mk_bound_variable_kinds_from_iter(iter) + } + + pub fn mk_place_elems(&self, v: &[mir::PlaceElem<'tcx>]) -> &'tcx List> { + self.tcx.mk_place_elems(v) + } + + pub fn adt_def(&self, def_id: DefId) -> AdtDef<'tcx> { + self.tcx.adt_def(def_id) + } + + pub fn coroutine_movability(&self, def_id: DefId) -> ty::Movability { + self.tcx.coroutine_movability(def_id) + } + + pub fn valtree_to_const_val(&self, key: ty::Value<'tcx>) -> ConstValue<'tcx> { + self.tcx.valtree_to_const_val(key) + } + + pub fn layout_of( + &self, + key: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>, + ) -> Result>, &ty::layout::LayoutError<'tcx>> { + self.tcx.layout_of(key) + } + + pub fn as_query_input( + &self, + typing_env: ty::TypingEnv<'tcx>, + value: T, + ) -> ty::PseudoCanonicalInput<'tcx, T> + where + T: ty::TypeVisitable>, + { + typing_env.as_query_input(value) + } + + pub fn target_endian(&self) -> Endian { + self.tcx.data_layout.endian + } + + pub fn target_pointer_size(&self) -> usize { + self.tcx.data_layout.pointer_size.bits().try_into().unwrap() + } + + pub fn entry_fn(&self) -> Option { + Some(self.tcx.entry_fn(())?.0) + } + + /// Retrieve all items of the local crate that have a MIR associated with them. + pub fn all_local_items(&self) -> Vec { + self.tcx.mir_keys(()).iter().map(|item| item.to_def_id()).collect() + } + + /// Retrieve the body of a function. + /// This function will panic if the body is not available. + pub fn mir_body(&self, item: DefId) -> &'tcx Body<'tcx> { + self.tcx.instance_mir(InstanceKind::Item(item)) + } + + /// 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 foreign_modules(&self, crate_num: CrateNum) -> Vec { + 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 { + filter_def_ids(self.tcx, crate_num, |def_id| tables.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 { + filter_def_ids(self.tcx, crate_num, |def_id| tables.filter_static_def(def_id)) + } + + pub fn foreign_module(&self, mod_def: DefId) -> &ForeignModule { + self.tcx.foreign_modules(mod_def.krate).get(&mod_def).unwrap() + } + + pub fn foreign_items(&self, mod_def: DefId) -> Vec { + self.tcx + .foreign_modules(mod_def.krate) + .get(&mod_def) + .unwrap() + .foreign_items + .iter() + .map(|item_def| *item_def) + .collect() + } + + pub fn all_trait_decls(&self) -> Vec { + self.tcx.all_traits().map(|trait_def_id| trait_def_id).collect() + } + + pub fn trait_decls(&self, crate_num: CrateNum) -> Vec { + self.tcx.traits(crate_num).iter().map(|trait_def_id| *trait_def_id).collect() + } + + pub fn trait_decl(&self, trait_def: DefId) -> &'tcx TraitDef { + self.tcx.trait_def(trait_def) + } + + pub fn all_trait_impls(&self) -> Vec { + iter::once(LOCAL_CRATE) + .chain(self.tcx.crates(()).iter().copied()) + .flat_map(|cnum| self.tcx.trait_impls_in_crate(cnum).iter()) + .map(|impl_def_id| *impl_def_id) + .collect() + } + + pub fn trait_impls(&self, crate_num: CrateNum) -> Vec { + self.tcx.trait_impls_in_crate(crate_num).iter().map(|impl_def_id| *impl_def_id).collect() + } + + pub fn trait_impl(&self, impl_def: DefId) -> EarlyBinder, TraitRef>> { + self.tcx.impl_trait_ref(impl_def).unwrap() + } + + pub fn generics_of(&self, def_id: DefId) -> &'tcx ty::Generics { + self.tcx.generics_of(def_id) + } + + pub fn predicates_of(&self, def_id: DefId) -> GenericPredicates<'tcx> { + self.tcx.predicates_of(def_id) + } + + pub fn explicit_predicates_of(&self, def_id: DefId) -> GenericPredicates<'tcx> { + self.tcx.explicit_predicates_of(def_id) + } + + pub fn crate_name(&self, crate_num: CrateNum) -> String { + self.tcx.crate_name(crate_num).to_string() + } + + pub fn crate_is_local(&self, crate_num: CrateNum) -> bool { + crate_num == LOCAL_CRATE + } + + pub fn crate_num_id(&self, crate_num: CrateNum) -> usize { + crate_num.into() + } + + pub fn local_crate_num(&self) -> CrateNum { + LOCAL_CRATE + } + + /// Retrieve a list of all external crates. + pub fn external_crates(&self) -> Vec { + self.tcx.crates(()).iter().map(|crate_num| *crate_num).collect() + } + + /// Find a crate with the given name. + pub fn find_crates(&self, name: &str) -> Vec { + let crates: Vec = [LOCAL_CRATE] + .iter() + .chain(self.tcx.crates(()).iter()) + .filter_map(|crate_num| { + let crate_name = self.tcx.crate_name(*crate_num).to_string(); + (name == crate_name).then(|| *crate_num) + }) + .collect(); + crates + } + + /// Returns the name of given `DefId`. + pub fn def_name(&self, def_id: DefId, trimmed: bool) -> String { + if trimmed { + with_forced_trimmed_paths!(self.tcx.def_path_str(def_id)) + } else { + with_no_trimmed_paths!(self.tcx.def_path_str(def_id)) + } + } + + /// Return registered tool attributes with the given attribute name. + /// + /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool + /// attributes will simply return an empty list. + /// + /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`. + /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`. + pub fn tool_attrs(&self, def_id: DefId, attr: &[String]) -> Vec<(String, Span)> { + let attr_name: Vec<_> = attr.iter().map(|seg| Symbol::intern(&seg)).collect(); + self.tcx + .get_attrs_by_path(def_id, &attr_name) + .filter_map(|attribute| { + if let Attribute::Unparsed(u) = attribute { + let attr_str = rustc_hir_pretty::attribute_to_string(&self.tcx, attribute); + Some((attr_str, u.span)) + } else { + None + } + }) + .collect() + } + + /// Get all tool attributes of a definition. + pub fn all_tool_attrs(&self, did: DefId) -> Vec<(String, Span)> { + let attrs_iter = if let Some(did) = did.as_local() { + self.tcx.hir_attrs(self.tcx.local_def_id_to_hir_id(did)).iter() + } else { + self.tcx.attrs_for_def(did).iter() + }; + attrs_iter + .filter_map(|attribute| { + if let Attribute::Unparsed(u) = attribute { + let attr_str = rustc_hir_pretty::attribute_to_string(&self.tcx, attribute); + Some((attr_str, u.span)) + } else { + None + } + }) + .collect() + } + + /// Returns printable, human readable form of `Span`. + pub fn span_to_string(&self, span: Span) -> String { + self.tcx.sess.source_map().span_to_diagnostic_string(span) + } + + /// Return filename from given `Span`, for diagnostic purposes. + pub fn get_filename(&self, span: Span) -> String { + self.tcx + .sess + .source_map() + .span_to_filename(span) + .display(FileNameDisplayPreference::Local) + .to_string() + } + + /// Return lines corresponding to this `Span`. + pub fn get_lines(&self, span: Span) -> (usize, usize, usize, usize) { + let lines = &self.tcx.sess.source_map().span_to_location_info(span); + (lines.1, lines.2, lines.3, lines.4) + } + + /// Returns the `kind` of given `DefId`. + pub fn def_kind(&self, item: DefId) -> DefKind { + self.tcx.def_kind(item) + } + + /// Returns whether this is a foreign item. + pub fn is_foreign_item(&self, item: DefId) -> bool { + self.tcx.is_foreign_item(item) + } + + /// Returns the kind of a given foreign item. + pub fn foreign_item_kind(&self, def_id: DefId) -> DefKind { + self.tcx.def_kind(def_id) + } + + /// Returns the kind of a given algebraic data type. + pub fn adt_kind(&self, def: AdtDef<'tcx>) -> AdtKind { + def.adt_kind() + } + + /// Returns if the ADT is a box. + pub fn adt_is_box(&self, def: AdtDef<'tcx>) -> bool { + def.is_box() + } + + /// Returns whether this ADT is simd. + pub fn adt_is_simd(&self, def: AdtDef<'tcx>) -> bool { + def.repr().simd() + } + + /// Returns whether this definition is a C string. + pub fn adt_is_cstr(&self, def_id: DefId) -> bool { + self.tcx.is_lang_item(def_id, LangItem::CStr) + } + + /// Retrieve the function signature for the given generic arguments. + pub fn fn_sig( + &self, + def_id: DefId, + args_ref: GenericArgsRef<'tcx>, + ) -> Binder, FnSig>> { + let sig = self.tcx.fn_sig(def_id).instantiate(self.tcx, args_ref); + sig + } + + /// Retrieve the intrinsic definition if the item corresponds one. + pub fn intrinsic(&self, def_id: DefId) -> Option { + let intrinsic = self.tcx.intrinsic_raw(def_id); + intrinsic + } + + /// Retrieve the plain function name of an intrinsic. + pub fn intrinsic_name(&self, def_id: DefId) -> String { + self.tcx.intrinsic(def_id).unwrap().name.to_string() + } + + /// Retrieve the closure signature for the given generic arguments. + pub fn closure_sig( + &self, + args_ref: GenericArgsRef<'tcx>, + ) -> Binder, FnSig>> { + args_ref.as_closure().sig() + } + + /// The number of variants in this ADT. + pub fn adt_variants_len(&self, def: AdtDef<'tcx>) -> usize { + def.variants().len() + } + + /// The name of a variant. + pub fn variant_name(&self, def: &'tcx VariantDef) -> String { + def.name.to_string() + } + + /// Evaluate constant as a target usize. + pub fn eval_target_usize(&self, cnst: MirConst<'tcx>) -> Result { + use crate::rustc_smir::context::SmirTypingEnv; + cnst.try_eval_target_usize(self.tcx, self.fully_monomorphized()) + .ok_or_else(|| B::Error::new(format!("Const `{cnst:?}` cannot be encoded as u64"))) + } + + pub fn eval_target_usize_ty(&self, cnst: ty::Const<'tcx>) -> Result { + cnst.try_to_target_usize(self.tcx) + .ok_or_else(|| B::Error::new(format!("Const `{cnst:?}` cannot be encoded as u64"))) + } + + pub(crate) fn try_new_const_zst( + &self, + ty_internal: Ty<'tcx>, + ) -> Result, B::Error> { + let size = self + .tcx + .layout_of(self.fully_monomorphized().as_query_input(ty_internal)) + .map_err(|err| { + B::Error::new(format!( + "Cannot create a zero-sized constant for type `{ty_internal}`: {err}" + )) + })? + .size; + if size.bytes() != 0 { + return Err(B::Error::new(format!( + "Cannot create a zero-sized constant for type `{ty_internal}`: \ + Type `{ty_internal}` has {} bytes", + size.bytes() + ))); + } + + Ok(MirConst::Ty(ty_internal, self.const_zero_sized(ty_internal))) + } + + pub fn const_zero_sized(&self, ty_internal: Ty<'tcx>) -> ty::Const<'tcx> { + ty::Const::zero_sized(self.tcx, ty_internal) + } + + /// Create a new constant that represents the given string value. + pub fn new_const_str(&self, value: &str) -> MirConst<'tcx> { + let ty = Ty::new_static_str(self.tcx); + let bytes = value.as_bytes(); + let valtree = ValTree::from_raw_bytes(self.tcx, bytes); + let cv = ty::Value { ty, valtree }; + let val = self.tcx.valtree_to_const_val(cv); + MirConst::from_value(val, ty) + } + + /// Create a new constant that represents the given boolean value. + pub fn new_const_bool(&self, value: bool) -> MirConst<'tcx> { + MirConst::from_bool(self.tcx, value) + } + + pub fn try_new_const_uint( + &self, + value: u128, + ty_internal: Ty<'tcx>, + ) -> Result, B::Error> { + let size = self + .tcx + .layout_of(self.fully_monomorphized().as_query_input(ty_internal)) + .unwrap() + .size; + let scalar = ScalarInt::try_from_uint(value, size).ok_or_else(|| { + B::Error::new(format!("Value overflow: cannot convert `{value}` to `{ty_internal}`.")) + })?; + Ok(self.mir_const_from_scalar(Scalar::Int(scalar), ty_internal)) + } + + pub fn try_new_ty_const_uint( + &self, + value: u128, + ty_internal: Ty<'tcx>, + ) -> Result, B::Error> { + let size = self + .tcx + .layout_of(self.fully_monomorphized().as_query_input(ty_internal)) + .unwrap() + .size; + let scalar = ScalarInt::try_from_uint(value, size).ok_or_else(|| { + B::Error::new(format!("Value overflow: cannot convert `{value}` to `{ty_internal}`.")) + })?; + + Ok(self.ty_const_new_value(ValTree::from_scalar_int(self.tcx, scalar), ty_internal)) + } + + pub fn ty_new_uint(&self, ty: UintTy) -> Ty<'tcx> { + Ty::new_uint(self.tcx, ty) + } + + pub fn mir_const_from_scalar(&self, s: Scalar, ty: Ty<'tcx>) -> MirConst<'tcx> { + MirConst::from_scalar(self.tcx, s, ty) + } + + pub fn ty_const_new_value(&self, valtree: ValTree<'tcx>, ty: Ty<'tcx>) -> ty::Const<'tcx> { + ty::Const::new_value(self.tcx, valtree, ty) + } + + pub fn ty_valtree_from_scalar_int(&self, i: ScalarInt) -> ValTree<'tcx> { + ValTree::from_scalar_int(self.tcx, i) + } + + /// Create a new type from the given kind. + pub fn new_rigid_ty(&self, internal_kind: TyKind<'tcx>) -> Ty<'tcx> { + self.tcx.mk_ty_from_kind(internal_kind) + } + + /// Create a new box type, `Box`, for the given inner type `T`. + pub fn new_box_ty(&self, ty: Ty<'tcx>) -> Ty<'tcx> { + ty::Ty::new_box(self.tcx, ty) + } + + /// Returns the type of given crate item. + pub fn def_ty(&self, item: DefId) -> Ty<'tcx> { + self.tcx.type_of(item).instantiate_identity() + } + + /// Returns the type of given definition instantiated with the given arguments. + pub fn def_ty_with_args(&self, item: DefId, args_ref: GenericArgsRef<'tcx>) -> Ty<'tcx> { + let def_ty = self.tcx.type_of(item); + self.tcx.instantiate_and_normalize_erasing_regions( + args_ref, + self.fully_monomorphized(), + def_ty, + ) + } + + /// `Span` of an item. + pub fn span_of_an_item(&self, def_id: DefId) -> Span { + self.tcx.def_span(def_id) + } + + pub fn ty_const_pretty(&self, ct: ty::Const<'tcx>) -> String { + ct.to_string() + } + + /// Obtain the representation of a type. + pub fn ty_pretty(&self, ty: Ty<'tcx>) -> String { + ty.to_string() + } + + /// Obtain the kind of a type. + pub fn ty_kind(&self, ty: Ty<'tcx>) -> &'tcx TyKind<'tcx> { + ty.kind() + } + + /// Get the discriminant Ty for this Ty if there's one. + pub fn rigid_ty_discriminant_ty(&self, internal_kind: TyKind<'tcx>) -> Ty<'tcx> { + let internal_ty = self.tcx.mk_ty_from_kind(internal_kind); + internal_ty.discriminant_ty(self.tcx) + } + + /// 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> { + tables + .instance_has_body(instance) + .then(|| BodyBuilder::new(self.tcx, instance).build(tables)) + } + + /// Get the instance type with generic instantiations applied and lifetimes erased. + pub fn instance_ty(&self, instance: ty::Instance<'tcx>) -> Ty<'tcx> { + assert!(!instance.has_non_region_param(), "{instance:?} needs further instantiation"); + instance.ty(self.tcx, self.fully_monomorphized()) + } + + /// Get the instantiation types. + pub fn instance_args(&self, instance: ty::Instance<'tcx>) -> GenericArgsRef<'tcx> { + instance.args + } + + /// Get an instance ABI. + 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())?) + } + + /// 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())?) + } + + /// Get the instance. + pub fn instance_def_id( + &self, + instances: ty::Instance<'tcx>, + tables: &mut Tables<'_, B>, + ) -> B::DefId { + let def_id = instances.def_id(); + tables.create_def_id(def_id) + } + + /// Get the instance mangled name. + pub fn instance_mangled_name(&self, instance: ty::Instance<'tcx>) -> String { + self.tcx.symbol_name(instance).name.to_string() + } + + /// Check if this is an empty DropGlue shim. + pub fn is_empty_drop_shim(&self, instance: ty::Instance<'tcx>) -> bool { + matches!(instance.def, ty::InstanceKind::DropGlue(_, None)) + } + + /// Convert a non-generic crate item into an instance. + /// This function will panic if the item is generic. + pub fn mono_instance(&self, def_id: DefId) -> Instance<'tcx> { + Instance::mono(self.tcx, def_id) + } + + /// Item requires monomorphization. + pub fn requires_monomorphization(&self, def_id: DefId) -> bool { + let generics = self.tcx.generics_of(def_id); + let result = generics.requires_monomorphization(self.tcx); + result + } + + /// Resolve an instance from the given function definition and generic arguments. + pub fn resolve_instance( + &self, + def_id: DefId, + args_ref: GenericArgsRef<'tcx>, + ) -> Option> { + match Instance::try_resolve(self.tcx, self.fully_monomorphized(), def_id, args_ref) { + Ok(Some(instance)) => Some(instance), + Ok(None) | Err(_) => None, + } + } + + /// Resolve an instance for drop_in_place for the given type. + pub fn resolve_drop_in_place(&self, internal_ty: Ty<'tcx>) -> Instance<'tcx> { + let instance = Instance::resolve_drop_in_place(self.tcx, internal_ty); + instance + } + + /// Resolve instance for a function pointer. + pub fn resolve_for_fn_ptr( + &self, + def_id: DefId, + args_ref: GenericArgsRef<'tcx>, + ) -> Option> { + Instance::resolve_for_fn_ptr(self.tcx, self.fully_monomorphized(), def_id, args_ref) + } + + /// Resolve instance for a closure with the requested type. + pub fn resolve_closure( + &self, + def_id: DefId, + args_ref: GenericArgsRef<'tcx>, + closure_kind: ClosureKind, + ) -> Option> { + Some(Instance::resolve_closure(self.tcx, def_id, args_ref, closure_kind)) + } + + /// Try to evaluate an instance into a constant. + pub fn eval_instance( + &self, + instance: ty::Instance<'tcx>, + ) -> Result, ErrorHandled> { + self.tcx.const_eval_instance( + self.fully_monomorphized(), + instance, + self.tcx.def_span(instance.def_id()), + ) + } + + /// Evaluate a static's initializer. + pub fn eval_static_initializer( + &self, + def_id: DefId, + ) -> Result, ErrorHandled> { + self.tcx.eval_static_initializer(def_id) + } + + /// Retrieve global allocation for the given allocation ID. + pub fn global_alloc(&self, alloc_id: AllocId) -> GlobalAlloc<'tcx> { + self.tcx.global_alloc(alloc_id) + } + + /// Retrieve the id for the virtual table. + pub fn vtable_allocation( + &self, + ty: Ty<'tcx>, + trait_ref: Option, ExistentialTraitRef>>>, + ) -> AllocId { + let alloc_id = self.tcx.vtable_allocation(( + ty, + trait_ref.map(|principal| self.tcx.instantiate_bound_regions_with_erased(principal)), + )); + alloc_id + } + + /// Retrieve the instance name for diagnostic messages. + /// + /// This will return the specialized name, e.g., `Vec::new`. + pub fn instance_name(&self, instance: ty::Instance<'tcx>, trimmed: bool) -> String { + if trimmed { + with_forced_trimmed_paths!( + self.tcx.def_path_str_with_args(instance.def_id(), instance.args) + ) + } else { + with_no_trimmed_paths!( + self.tcx.def_path_str_with_args(instance.def_id(), instance.args) + ) + } + } + + /// Get the layout of a type. + pub fn ty_layout( + &self, + ty: Ty<'tcx>, + tables: &mut Tables<'tcx, B>, + ) -> Result, B::Error> { + let layout = tables.layout_of(ty)?.layout; + Ok(layout) + } + + /// Get the resulting type of binary operation. + pub fn binop_ty(&self, bin_op: BinOp, rhs: Ty<'tcx>, lhs: Ty<'tcx>) -> Ty<'tcx> { + bin_op.ty(self.tcx, rhs, lhs) + } + + /// Get the resulting type of unary operation. + pub fn unop_ty(&self, un_op: UnOp, arg: Ty<'tcx>) -> Ty<'tcx> { + un_op.ty(self.tcx, arg) + } + + /// Get all associated items of a definition. + pub fn associated_items(&self, def_id: DefId) -> Vec { + let assoc_items = if self.tcx.is_trait_alias(def_id) { + Vec::new() + } else { + self.tcx + .associated_item_def_ids(def_id) + .iter() + .map(|did| self.tcx.associated_item(*did)) + .collect() + }; + assoc_items + } +} diff --git a/compiler/rustc_smir/src/rustc_smir/context/mod.rs b/compiler/rustc_smir/src/rustc_smir/context/mod.rs new file mode 100644 index 0000000000000..75acede8d3451 --- /dev/null +++ b/compiler/rustc_smir/src/rustc_smir/context/mod.rs @@ -0,0 +1,79 @@ +//! Implementation of StableMIR Context. + +#![allow(rustc::usage_of_qualified_ty)] + +use std::marker::PhantomData; + +use rustc_abi::HasDataLayout; +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}; + +mod impls; +mod traits; + +pub use traits::*; + +/// Provides direct access to rustc's internal queries. +/// +/// 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>, + _marker: PhantomData, +} + +impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { + pub(crate) fn new(tcx: TyCtxt<'tcx>) -> Self { + Self { tcx, _marker: Default::default() } + } +} + +/// Implement error handling for extracting function ABI information. +impl<'tcx, B: Bridge> FnAbiOfHelpers<'tcx> for Tables<'tcx, B> { + type FnAbiOfResult = Result<&'tcx rustc_target::callconv::FnAbi<'tcx, Ty<'tcx>>, B::Error>; + + #[inline] + fn handle_fn_abi_err( + &self, + err: ty::layout::FnAbiError<'tcx>, + _span: rustc_span::Span, + fn_abi_request: ty::layout::FnAbiRequest<'tcx>, + ) -> B::Error { + B::Error::new(format!("Failed to get ABI for `{fn_abi_request:?}`: {err:?}")) + } +} + +impl<'tcx, B: Bridge> LayoutOfHelpers<'tcx> for Tables<'tcx, B> { + type LayoutOfResult = Result, B::Error>; + + #[inline] + fn handle_layout_err( + &self, + err: ty::layout::LayoutError<'tcx>, + _span: rustc_span::Span, + ty: Ty<'tcx>, + ) -> B::Error { + B::Error::new(format!("Failed to get layout for `{ty}`: {err}")) + } +} + +impl<'tcx, B: Bridge> HasTypingEnv<'tcx> for Tables<'tcx, B> { + fn typing_env(&self) -> ty::TypingEnv<'tcx> { + ty::TypingEnv::fully_monomorphized() + } +} + +impl<'tcx, B: Bridge> HasTyCtxt<'tcx> for Tables<'tcx, B> { + fn tcx(&self) -> TyCtxt<'tcx> { + self.tcx + } +} + +impl<'tcx, B: Bridge> HasDataLayout for Tables<'tcx, B> { + fn data_layout(&self) -> &rustc_abi::TargetDataLayout { + self.tcx.data_layout() + } +} diff --git a/compiler/rustc_smir/src/rustc_smir/context/traits.rs b/compiler/rustc_smir/src/rustc_smir/context/traits.rs new file mode 100644 index 0000000000000..f5cd7c330b8fe --- /dev/null +++ b/compiler/rustc_smir/src/rustc_smir/context/traits.rs @@ -0,0 +1,50 @@ +//! A set of traits that define a stable interface to rustc's internals. +//! +//! These traits abstract rustc's internal APIs, allowing StableMIR to maintain a stable +//! interface regardless of internal compiler changes. + +use rustc_middle::mir::interpret::AllocRange; +use rustc_middle::ty; +use rustc_middle::ty::Ty; +use rustc_span::def_id::DefId; + +pub trait SmirExistentialProjection<'tcx> { + fn new_from_args( + &self, + def_id: DefId, + args: ty::GenericArgsRef<'tcx>, + term: ty::Term<'tcx>, + ) -> ty::ExistentialProjection<'tcx>; +} + +pub trait SmirExistentialTraitRef<'tcx> { + fn new_from_args( + &self, + trait_def_id: DefId, + args: ty::GenericArgsRef<'tcx>, + ) -> ty::ExistentialTraitRef<'tcx>; +} + +pub trait SmirTraitRef<'tcx> { + fn new_from_args( + &self, + trait_def_id: DefId, + args: ty::GenericArgsRef<'tcx>, + ) -> ty::TraitRef<'tcx>; +} + +pub trait SmirTy<'tcx> { + fn new_foreign(&self, def_id: DefId) -> Ty<'tcx>; +} + +pub trait SmirTypingEnv<'tcx> { + fn fully_monomorphized(&self) -> ty::TypingEnv<'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>; +} From ed5d4bb9d5d2a0b09c6f6e30c9e895c29c07f6de Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 5 May 2025 15:35:54 +0800 Subject: [PATCH 07/22] refactor: move `convert` module to `stable_mir` note that this commit delete `convert/error.rs`, we would use `SmirError::from_internal` instead. **Unresolved questions:** - There are still a few direct calls to rustc's internals scattered across `impl Stable`s, but most of them appear to be relatively stable, e.g., `mir::interpret::ConstAllocation::inner(self)` and `mir::syntax::SwitchTargets::otherwise(self)`. --- compiler/rustc_smir/src/rustc_internal/mod.rs | 11 +- .../src/rustc_smir/convert/error.rs | 25 - compiler/rustc_smir/src/rustc_smir/mod.rs | 1 - .../src/stable_mir/compiler_interface.rs | 1 + .../convert}/internal.rs | 458 +++++++++++----- .../rustc_smir/src/stable_mir/convert/mod.rs | 126 +++++ .../convert/stable}/abi.rs | 157 ++++-- .../convert/stable}/mir.rs | 502 +++++++++++------- .../convert/stable}/mod.rs | 36 +- .../convert/stable}/ty.rs | 498 +++++++++++------ compiler/rustc_smir/src/stable_mir/mod.rs | 1 + 11 files changed, 1226 insertions(+), 590 deletions(-) delete mode 100644 compiler/rustc_smir/src/rustc_smir/convert/error.rs rename compiler/rustc_smir/src/{rustc_internal => stable_mir/convert}/internal.rs (59%) create mode 100644 compiler/rustc_smir/src/stable_mir/convert/mod.rs rename compiler/rustc_smir/src/{rustc_smir/convert => stable_mir/convert/stable}/abi.rs (69%) rename compiler/rustc_smir/src/{rustc_smir/convert => stable_mir/convert/stable}/mir.rs (68%) rename compiler/rustc_smir/src/{rustc_smir/convert => stable_mir/convert/stable}/mod.rs (68%) rename compiler/rustc_smir/src/{rustc_smir/convert => stable_mir/convert/stable}/ty.rs (69%) diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs index c343242ddfc57..5947a7a844054 100644 --- a/compiler/rustc_smir/src/rustc_internal/mod.rs +++ b/compiler/rustc_smir/src/rustc_internal/mod.rs @@ -17,13 +17,12 @@ use rustc_span::Span; use rustc_span::def_id::{CrateNum, DefId}; use scoped_tls::scoped_thread_local; use stable_mir::Error; +use stable_mir::convert::{RustcInternal, Stable}; use crate::rustc_smir::context::SmirCtxt; -use crate::rustc_smir::{Stable, Tables}; use crate::rustc_smir::{Bridge, IndexedVal, SmirContainer, Tables}; use crate::stable_mir; -mod internal; pub mod pretty; /// Convert an internal Rust compiler item into its stable counterpart, if one exists. @@ -340,11 +339,3 @@ impl Index; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx>; -} diff --git a/compiler/rustc_smir/src/rustc_smir/convert/error.rs b/compiler/rustc_smir/src/rustc_smir/convert/error.rs deleted file mode 100644 index 2cde5542483db..0000000000000 --- a/compiler/rustc_smir/src/rustc_smir/convert/error.rs +++ /dev/null @@ -1,25 +0,0 @@ -//! Handle the conversion of different internal errors into a stable version. -//! -//! Currently we encode everything as [stable_mir::Error], which is represented as a string. - -use rustc_middle::mir::interpret::AllocError; -use rustc_middle::ty::layout::LayoutError; - -use crate::rustc_smir::{Stable, Tables}; -use crate::stable_mir; - -impl<'tcx> Stable<'tcx> for LayoutError<'tcx> { - type T = stable_mir::Error; - - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { - stable_mir::Error::new(format!("{self:?}")) - } -} - -impl<'tcx> Stable<'tcx> for AllocError { - type T = stable_mir::Error; - - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { - stable_mir::Error::new(format!("{self:?}")) - } -} diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs index 03b3a93dc069c..3da67e15cb0b5 100644 --- a/compiler/rustc_smir/src/rustc_smir/mod.rs +++ b/compiler/rustc_smir/src/rustc_smir/mod.rs @@ -23,7 +23,6 @@ use crate::rustc_internal::IndexMap; pub mod alloc; mod builder; pub mod context; -mod convert; /// A container which is used for TLS. pub struct SmirContainer<'tcx, B: Bridge> { diff --git a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs index a3dd612b2f933..a041339284fd3 100644 --- a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs +++ b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs @@ -8,6 +8,7 @@ use std::cell::Cell; use rustc_hir::def::DefKind; use rustc_smir::{Bridge, SmirContainer, Tables}; use stable_mir::abi::{FnAbi, Layout, LayoutShape, ReprOptions}; +use stable_mir::convert::{RustcInternal, Stable}; use stable_mir::crate_def::Attribute; use stable_mir::mir::alloc::{AllocId, GlobalAlloc}; use stable_mir::mir::mono::{Instance, InstanceDef, StaticDef}; diff --git a/compiler/rustc_smir/src/rustc_internal/internal.rs b/compiler/rustc_smir/src/stable_mir/convert/internal.rs similarity index 59% rename from compiler/rustc_smir/src/rustc_internal/internal.rs rename to compiler/rustc_smir/src/stable_mir/convert/internal.rs index a4c6f18622218..9006e5ca28190 100644 --- a/compiler/rustc_smir/src/rustc_internal/internal.rs +++ b/compiler/rustc_smir/src/stable_mir/convert/internal.rs @@ -5,93 +5,132 @@ // Prefer importing stable_mir over internal rustc constructs to make this file more readable. -use rustc_middle::ty::{self as rustc_ty, Const as InternalConst, Ty as InternalTy, TyCtxt}; +use rustc_middle::ty::{self as rustc_ty, Const as InternalConst, Ty as InternalTy}; +use rustc_smir::context::SmirCtxt; +use rustc_smir::{IndexedVal, Tables}; use rustc_span::Symbol; use stable_mir::abi::Layout; +use stable_mir::compiler_interface::BridgeTys; +use stable_mir::convert::RustcInternal; use stable_mir::mir::alloc::AllocId; use stable_mir::mir::mono::{Instance, MonoItem, StaticDef}; use stable_mir::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp}; use stable_mir::ty::{ Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind, DynKind, ExistentialPredicate, ExistentialProjection, ExistentialTraitRef, FloatTy, FnSig, - GenericArgKind, GenericArgs, IndexedVal, IntTy, MirConst, Movability, Pattern, Region, RigidTy, - Span, TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx, + GenericArgKind, GenericArgs, IntTy, MirConst, Movability, Pattern, Region, RigidTy, Span, + TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx, }; use stable_mir::{CrateItem, CrateNum, DefId}; -use super::RustcInternal; -use crate::rustc_smir::Tables; -use crate::stable_mir; +use crate::{rustc_smir, stable_mir}; impl RustcInternal for CrateItem { type T<'tcx> = rustc_span::def_id::DefId; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - self.0.internal(tables, tcx) + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + self.0.internal(tables, cx) } } impl RustcInternal for CrateNum { type T<'tcx> = rustc_span::def_id::CrateNum; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { rustc_span::def_id::CrateNum::from_usize(*self) } } impl RustcInternal for DefId { type T<'tcx> = rustc_span::def_id::DefId; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tcx.lift(tables.def_ids[*self]).unwrap() + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + cx.lift(tables.def_ids[*self]).unwrap() } } impl RustcInternal for GenericArgs { type T<'tcx> = rustc_ty::GenericArgsRef<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tcx.mk_args_from_iter(self.0.iter().map(|arg| arg.internal(tables, tcx))) + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + cx.mk_args_from_iter(self.0.iter().map(|arg| arg.internal(tables, cx))) } } impl RustcInternal for GenericArgKind { type T<'tcx> = rustc_ty::GenericArg<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { let arg: rustc_ty::GenericArg<'tcx> = match self { - GenericArgKind::Lifetime(reg) => reg.internal(tables, tcx).into(), - GenericArgKind::Type(ty) => ty.internal(tables, tcx).into(), - GenericArgKind::Const(cnst) => cnst.internal(tables, tcx).into(), + GenericArgKind::Lifetime(reg) => reg.internal(tables, cx).into(), + GenericArgKind::Type(ty) => ty.internal(tables, cx).into(), + GenericArgKind::Const(cnst) => cnst.internal(tables, cx).into(), }; - tcx.lift(arg).unwrap() + cx.lift(arg).unwrap() } } impl RustcInternal for Region { type T<'tcx> = rustc_ty::Region<'tcx>; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { // Cannot recover region. Use erased for now. - tcx.lifetimes.re_erased + use rustc_smir::context::SmirRegion; + cx.lifetimes_re_erased() } } impl RustcInternal for Ty { type T<'tcx> = InternalTy<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tcx.lift(tables.types[*self]).unwrap() + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + cx.lift(tables.types[*self]).unwrap() } } impl RustcInternal for TyConst { type T<'tcx> = InternalConst<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tcx.lift(tables.ty_consts[self.id]).unwrap() + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + cx.lift(tables.ty_consts[self.id]).unwrap() } } impl RustcInternal for Pattern { type T<'tcx> = rustc_ty::Pattern<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tcx.mk_pat(match self { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + cx.mk_pat(match self { Pattern::Range { start, end, include_end: _ } => rustc_ty::PatternKind::Range { - start: start.as_ref().unwrap().internal(tables, tcx), - end: end.as_ref().unwrap().internal(tables, tcx), + start: start.as_ref().unwrap().internal(tables, cx), + end: end.as_ref().unwrap().internal(tables, cx), }, }) } @@ -100,62 +139,66 @@ impl RustcInternal for Pattern { impl RustcInternal for RigidTy { type T<'tcx> = rustc_ty::TyKind<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { RigidTy::Bool => rustc_ty::TyKind::Bool, RigidTy::Char => rustc_ty::TyKind::Char, - 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, tcx)), - RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables, tcx)), + RigidTy::Int(int_ty) => rustc_ty::TyKind::Int(int_ty.internal(tables, cx)), + RigidTy::Uint(uint_ty) => rustc_ty::TyKind::Uint(uint_ty.internal(tables, cx)), + RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables, cx)), RigidTy::Never => rustc_ty::TyKind::Never, RigidTy::Array(ty, cnst) => { - rustc_ty::TyKind::Array(ty.internal(tables, tcx), cnst.internal(tables, tcx)) + rustc_ty::TyKind::Array(ty.internal(tables, cx), cnst.internal(tables, cx)) } RigidTy::Pat(ty, pat) => { - rustc_ty::TyKind::Pat(ty.internal(tables, tcx), pat.internal(tables, tcx)) + rustc_ty::TyKind::Pat(ty.internal(tables, cx), pat.internal(tables, cx)) } RigidTy::Adt(def, args) => { - rustc_ty::TyKind::Adt(def.internal(tables, tcx), args.internal(tables, tcx)) + rustc_ty::TyKind::Adt(def.internal(tables, cx), args.internal(tables, cx)) } RigidTy::Str => rustc_ty::TyKind::Str, - RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, tcx)), + RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, cx)), RigidTy::RawPtr(ty, mutability) => { - rustc_ty::TyKind::RawPtr(ty.internal(tables, tcx), mutability.internal(tables, tcx)) + rustc_ty::TyKind::RawPtr(ty.internal(tables, cx), mutability.internal(tables, cx)) } RigidTy::Ref(region, ty, mutability) => rustc_ty::TyKind::Ref( - region.internal(tables, tcx), - ty.internal(tables, tcx), - mutability.internal(tables, tcx), + region.internal(tables, cx), + ty.internal(tables, cx), + mutability.internal(tables, cx), ), - RigidTy::Foreign(def) => rustc_ty::TyKind::Foreign(def.0.internal(tables, tcx)), + RigidTy::Foreign(def) => rustc_ty::TyKind::Foreign(def.0.internal(tables, cx)), RigidTy::FnDef(def, args) => { - rustc_ty::TyKind::FnDef(def.0.internal(tables, tcx), args.internal(tables, tcx)) + rustc_ty::TyKind::FnDef(def.0.internal(tables, cx), args.internal(tables, cx)) } RigidTy::FnPtr(sig) => { - let (sig_tys, hdr) = sig.internal(tables, tcx).split(); + let (sig_tys, hdr) = sig.internal(tables, cx).split(); rustc_ty::TyKind::FnPtr(sig_tys, hdr) } RigidTy::Closure(def, args) => { - rustc_ty::TyKind::Closure(def.0.internal(tables, tcx), args.internal(tables, tcx)) + rustc_ty::TyKind::Closure(def.0.internal(tables, cx), args.internal(tables, cx)) } RigidTy::Coroutine(def, args, _mov) => { - rustc_ty::TyKind::Coroutine(def.0.internal(tables, tcx), args.internal(tables, tcx)) + rustc_ty::TyKind::Coroutine(def.0.internal(tables, cx), args.internal(tables, cx)) } RigidTy::CoroutineClosure(def, args) => rustc_ty::TyKind::CoroutineClosure( - def.0.internal(tables, tcx), - args.internal(tables, tcx), + def.0.internal(tables, cx), + args.internal(tables, cx), ), RigidTy::CoroutineWitness(def, args) => rustc_ty::TyKind::CoroutineWitness( - def.0.internal(tables, tcx), - args.internal(tables, tcx), + def.0.internal(tables, cx), + args.internal(tables, cx), ), RigidTy::Dynamic(predicate, region, dyn_kind) => rustc_ty::TyKind::Dynamic( - tcx.mk_poly_existential_predicates(&predicate.internal(tables, tcx)), - region.internal(tables, tcx), - dyn_kind.internal(tables, tcx), + cx.mk_poly_existential_predicates(&predicate.internal(tables, cx)), + region.internal(tables, cx), + dyn_kind.internal(tables, cx), ), RigidTy::Tuple(tys) => { - rustc_ty::TyKind::Tuple(tcx.mk_type_list(&tys.internal(tables, tcx))) + rustc_ty::TyKind::Tuple(cx.mk_type_list(&tys.internal(tables, cx))) } } } @@ -164,7 +207,11 @@ impl RustcInternal for RigidTy { impl RustcInternal for IntTy { type T<'tcx> = rustc_ty::IntTy; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { IntTy::Isize => rustc_ty::IntTy::Isize, IntTy::I8 => rustc_ty::IntTy::I8, @@ -179,7 +226,11 @@ impl RustcInternal for IntTy { impl RustcInternal for UintTy { type T<'tcx> = rustc_ty::UintTy; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { UintTy::Usize => rustc_ty::UintTy::Usize, UintTy::U8 => rustc_ty::UintTy::U8, @@ -194,7 +245,11 @@ impl RustcInternal for UintTy { impl RustcInternal for FloatTy { type T<'tcx> = rustc_ty::FloatTy; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { FloatTy::F16 => rustc_ty::FloatTy::F16, FloatTy::F32 => rustc_ty::FloatTy::F32, @@ -207,7 +262,11 @@ impl RustcInternal for FloatTy { impl RustcInternal for Mutability { type T<'tcx> = rustc_ty::Mutability; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { Mutability::Not => rustc_ty::Mutability::Not, Mutability::Mut => rustc_ty::Mutability::Mut, @@ -218,7 +277,11 @@ impl RustcInternal for Mutability { impl RustcInternal for Movability { type T<'tcx> = rustc_ty::Movability; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { Movability::Static => rustc_ty::Movability::Static, Movability::Movable => rustc_ty::Movability::Movable, @@ -229,7 +292,11 @@ impl RustcInternal for Movability { impl RustcInternal for RawPtrKind { type T<'tcx> = rustc_middle::mir::RawPtrKind; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { RawPtrKind::Mut => rustc_middle::mir::RawPtrKind::Mut, RawPtrKind::Const => rustc_middle::mir::RawPtrKind::Const, @@ -241,12 +308,16 @@ impl RustcInternal for RawPtrKind { impl RustcInternal for FnSig { type T<'tcx> = rustc_ty::FnSig<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tcx.lift(rustc_ty::FnSig { - inputs_and_output: tcx.mk_type_list(&self.inputs_and_output.internal(tables, tcx)), + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + cx.lift(rustc_ty::FnSig { + inputs_and_output: cx.mk_type_list(&self.inputs_and_output.internal(tables, cx)), c_variadic: self.c_variadic, - safety: self.safety.internal(tables, tcx), - abi: self.abi.internal(tables, tcx), + safety: self.safety.internal(tables, cx), + abi: self.abi.internal(tables, cx), }) .unwrap() } @@ -255,7 +326,11 @@ impl RustcInternal for FnSig { impl RustcInternal for VariantIdx { type T<'tcx> = rustc_abi::VariantIdx; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { rustc_abi::VariantIdx::from(self.to_index()) } } @@ -263,27 +338,35 @@ impl RustcInternal for VariantIdx { impl RustcInternal for VariantDef { type T<'tcx> = &'tcx rustc_ty::VariantDef; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - self.adt_def.internal(tables, tcx).variant(self.idx.internal(tables, tcx)) + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + self.adt_def.internal(tables, cx).variant(self.idx.internal(tables, cx)) } } impl RustcInternal for MirConst { type T<'tcx> = rustc_middle::mir::Const<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { let constant = tables.mir_consts[self.id]; match constant { rustc_middle::mir::Const::Ty(ty, ct) => { - rustc_middle::mir::Const::Ty(tcx.lift(ty).unwrap(), tcx.lift(ct).unwrap()) + rustc_middle::mir::Const::Ty(cx.lift(ty).unwrap(), cx.lift(ct).unwrap()) } rustc_middle::mir::Const::Unevaluated(uneval, ty) => { rustc_middle::mir::Const::Unevaluated( - tcx.lift(uneval).unwrap(), - tcx.lift(ty).unwrap(), + cx.lift(uneval).unwrap(), + cx.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()) + rustc_middle::mir::Const::Val(cx.lift(const_val).unwrap(), cx.lift(ty).unwrap()) } } } @@ -292,11 +375,15 @@ impl RustcInternal for MirConst { impl RustcInternal for MonoItem { type T<'tcx> = rustc_middle::mir::mono::MonoItem<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { use rustc_middle::mir::mono as rustc_mono; match self { - MonoItem::Fn(instance) => rustc_mono::MonoItem::Fn(instance.internal(tables, tcx)), - MonoItem::Static(def) => rustc_mono::MonoItem::Static(def.internal(tables, tcx)), + MonoItem::Fn(instance) => rustc_mono::MonoItem::Fn(instance.internal(tables, cx)), + MonoItem::Static(def) => rustc_mono::MonoItem::Static(def.internal(tables, cx)), MonoItem::GlobalAsm(_) => { unimplemented!() } @@ -307,16 +394,24 @@ impl RustcInternal for MonoItem { impl RustcInternal for Instance { type T<'tcx> = rustc_ty::Instance<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tcx.lift(tables.instances[self.def]).unwrap() + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + cx.lift(tables.instances[self.def]).unwrap() } } impl RustcInternal for StaticDef { type T<'tcx> = rustc_span::def_id::DefId; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - self.0.internal(tables, tcx) + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + self.0.internal(tables, cx) } } @@ -328,11 +423,15 @@ where { type T<'tcx> = rustc_ty::Binder<'tcx, T::T<'tcx>>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { rustc_ty::Binder::bind_with_vars( - self.value.internal(tables, tcx), - tcx.mk_bound_variable_kinds_from_iter( - self.bound_vars.iter().map(|bound| bound.internal(tables, tcx)), + self.value.internal(tables, cx), + cx.mk_bound_variable_kinds_from_iter( + self.bound_vars.iter().map(|bound| bound.internal(tables, cx)), ), ) } @@ -341,19 +440,22 @@ where impl RustcInternal for BoundVariableKind { type T<'tcx> = rustc_ty::BoundVariableKind; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { BoundVariableKind::Ty(kind) => rustc_ty::BoundVariableKind::Ty(match kind { BoundTyKind::Anon => rustc_ty::BoundTyKind::Anon, - BoundTyKind::Param(def, symbol) => rustc_ty::BoundTyKind::Param( - def.0.internal(tables, tcx), - Symbol::intern(symbol), - ), + BoundTyKind::Param(def, symbol) => { + rustc_ty::BoundTyKind::Param(def.0.internal(tables, cx), Symbol::intern(symbol)) + } }), BoundVariableKind::Region(kind) => rustc_ty::BoundVariableKind::Region(match kind { BoundRegionKind::BrAnon => rustc_ty::BoundRegionKind::Anon, BoundRegionKind::BrNamed(def, symbol) => rustc_ty::BoundRegionKind::Named( - def.0.internal(tables, tcx), + def.0.internal(tables, cx), Symbol::intern(symbol), ), BoundRegionKind::BrEnv => rustc_ty::BoundRegionKind::ClosureEnv, @@ -366,7 +468,11 @@ impl RustcInternal for BoundVariableKind { impl RustcInternal for DynKind { type T<'tcx> = rustc_ty::DynKind; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { DynKind::Dyn => rustc_ty::DynKind::Dyn, DynKind::DynStar => rustc_ty::DynKind::DynStar, @@ -377,16 +483,20 @@ impl RustcInternal for DynKind { impl RustcInternal for ExistentialPredicate { type T<'tcx> = rustc_ty::ExistentialPredicate<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { ExistentialPredicate::Trait(trait_ref) => { - rustc_ty::ExistentialPredicate::Trait(trait_ref.internal(tables, tcx)) + rustc_ty::ExistentialPredicate::Trait(trait_ref.internal(tables, cx)) } ExistentialPredicate::Projection(proj) => { - rustc_ty::ExistentialPredicate::Projection(proj.internal(tables, tcx)) + rustc_ty::ExistentialPredicate::Projection(proj.internal(tables, cx)) } ExistentialPredicate::AutoTrait(trait_def) => { - rustc_ty::ExistentialPredicate::AutoTrait(trait_def.0.internal(tables, tcx)) + rustc_ty::ExistentialPredicate::AutoTrait(trait_def.0.internal(tables, cx)) } } } @@ -395,12 +505,16 @@ impl RustcInternal for ExistentialPredicate { impl RustcInternal for ExistentialProjection { type T<'tcx> = rustc_ty::ExistentialProjection<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - rustc_ty::ExistentialProjection::new_from_args( - tcx, - self.def_id.0.internal(tables, tcx), - self.generic_args.internal(tables, tcx), - self.term.internal(tables, tcx), + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + use rustc_smir::context::SmirExistentialProjection; + cx.new_from_args( + self.def_id.0.internal(tables, cx), + self.generic_args.internal(tables, cx), + self.term.internal(tables, cx), ) } } @@ -408,10 +522,14 @@ impl RustcInternal for ExistentialProjection { impl RustcInternal for TermKind { type T<'tcx> = rustc_ty::Term<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { - TermKind::Type(ty) => ty.internal(tables, tcx).into(), - TermKind::Const(cnst) => cnst.internal(tables, tcx).into(), + TermKind::Type(ty) => ty.internal(tables, cx).into(), + TermKind::Const(cnst) => cnst.internal(tables, cx).into(), } } } @@ -419,38 +537,48 @@ impl RustcInternal for TermKind { impl RustcInternal for ExistentialTraitRef { type T<'tcx> = rustc_ty::ExistentialTraitRef<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - rustc_ty::ExistentialTraitRef::new_from_args( - tcx, - self.def_id.0.internal(tables, tcx), - self.generic_args.internal(tables, tcx), - ) + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + use rustc_smir::context::SmirExistentialTraitRef; + cx.new_from_args(self.def_id.0.internal(tables, cx), self.generic_args.internal(tables, cx)) } } impl RustcInternal for TraitRef { type T<'tcx> = rustc_ty::TraitRef<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - rustc_ty::TraitRef::new_from_args( - tcx, - self.def_id.0.internal(tables, tcx), - self.args().internal(tables, tcx), - ) + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + use rustc_smir::context::SmirTraitRef; + cx.new_from_args(self.def_id.0.internal(tables, cx), self.args().internal(tables, cx)) } } impl RustcInternal for AllocId { type T<'tcx> = rustc_middle::mir::interpret::AllocId; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tcx.lift(tables.alloc_ids[*self]).unwrap() + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + cx.lift(tables.alloc_ids[*self]).unwrap() } } impl RustcInternal for ClosureKind { type T<'tcx> = rustc_ty::ClosureKind; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { ClosureKind::Fn => rustc_ty::ClosureKind::Fn, ClosureKind::FnMut => rustc_ty::ClosureKind::FnMut, @@ -461,15 +589,23 @@ impl RustcInternal for ClosureKind { impl RustcInternal for AdtDef { type T<'tcx> = rustc_ty::AdtDef<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tcx.adt_def(self.0.internal(tables, tcx)) + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + cx.adt_def(self.0.internal(tables, cx)) } } impl RustcInternal for Abi { type T<'tcx> = rustc_abi::ExternAbi; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match *self { Abi::Rust => rustc_abi::ExternAbi::Rust, Abi::C { unwind } => rustc_abi::ExternAbi::C { unwind }, @@ -504,7 +640,11 @@ impl RustcInternal for Abi { impl RustcInternal for Safety { type T<'tcx> = rustc_hir::Safety; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { Safety::Unsafe => rustc_hir::Safety::Unsafe, Safety::Safe => rustc_hir::Safety::Safe, @@ -514,26 +654,38 @@ impl RustcInternal for Safety { impl RustcInternal for Span { type T<'tcx> = rustc_span::Span; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tables[*self] + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + tables.spans[*self] } } impl RustcInternal for Layout { type T<'tcx> = rustc_abi::Layout<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - tcx.lift(tables.layouts[*self]).unwrap() + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + cx.lift(tables.layouts[*self]).unwrap() } } impl RustcInternal for Place { type T<'tcx> = rustc_middle::mir::Place<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { rustc_middle::mir::Place { local: rustc_middle::mir::Local::from_usize(self.local), - projection: tcx.mk_place_elems(&self.projection.internal(tables, tcx)), + projection: cx.mk_place_elems(&self.projection.internal(tables, cx)), } } } @@ -541,11 +693,15 @@ impl RustcInternal for Place { impl RustcInternal for ProjectionElem { type T<'tcx> = rustc_middle::mir::PlaceElem<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { ProjectionElem::Deref => rustc_middle::mir::PlaceElem::Deref, ProjectionElem::Field(idx, ty) => { - rustc_middle::mir::PlaceElem::Field((*idx).into(), ty.internal(tables, tcx)) + rustc_middle::mir::PlaceElem::Field((*idx).into(), ty.internal(tables, cx)) } ProjectionElem::Index(idx) => rustc_middle::mir::PlaceElem::Index((*idx).into()), ProjectionElem::ConstantIndex { offset, min_length, from_end } => { @@ -559,13 +715,13 @@ impl RustcInternal for ProjectionElem { rustc_middle::mir::PlaceElem::Subslice { from: *from, to: *to, from_end: *from_end } } ProjectionElem::Downcast(idx) => { - rustc_middle::mir::PlaceElem::Downcast(None, idx.internal(tables, tcx)) + rustc_middle::mir::PlaceElem::Downcast(None, idx.internal(tables, cx)) } ProjectionElem::OpaqueCast(ty) => { - rustc_middle::mir::PlaceElem::OpaqueCast(ty.internal(tables, tcx)) + rustc_middle::mir::PlaceElem::OpaqueCast(ty.internal(tables, cx)) } ProjectionElem::Subtype(ty) => { - rustc_middle::mir::PlaceElem::Subtype(ty.internal(tables, tcx)) + rustc_middle::mir::PlaceElem::Subtype(ty.internal(tables, cx)) } } } @@ -574,7 +730,11 @@ impl RustcInternal for ProjectionElem { impl RustcInternal for BinOp { type T<'tcx> = rustc_middle::mir::BinOp; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { BinOp::Add => rustc_middle::mir::BinOp::Add, BinOp::AddUnchecked => rustc_middle::mir::BinOp::AddUnchecked, @@ -606,7 +766,11 @@ impl RustcInternal for BinOp { impl RustcInternal for UnOp { type T<'tcx> = rustc_middle::mir::UnOp; - fn internal<'tcx>(&self, _tables: &mut Tables<'_>, _tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { + fn internal<'tcx>( + &self, + _tables: &mut Tables<'_, BridgeTys>, + _cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { match self { UnOp::Not => rustc_middle::mir::UnOp::Not, UnOp::Neg => rustc_middle::mir::UnOp::Neg, @@ -621,8 +785,12 @@ where { type T<'tcx> = T::T<'tcx>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - (*self).internal(tables, tcx) + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + (*self).internal(tables, cx) } } @@ -632,8 +800,12 @@ where { type T<'tcx> = Option>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - self.as_ref().map(|inner| inner.internal(tables, tcx)) + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + self.as_ref().map(|inner| inner.internal(tables, cx)) } } @@ -643,7 +815,11 @@ where { type T<'tcx> = Vec>; - fn internal<'tcx>(&self, tables: &mut Tables<'_>, tcx: TyCtxt<'tcx>) -> Self::T<'tcx> { - self.iter().map(|e| e.internal(tables, tcx)).collect() + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx> { + self.iter().map(|e| e.internal(tables, cx)).collect() } } diff --git a/compiler/rustc_smir/src/stable_mir/convert/mod.rs b/compiler/rustc_smir/src/stable_mir/convert/mod.rs new file mode 100644 index 0000000000000..90ed67ed972b0 --- /dev/null +++ b/compiler/rustc_smir/src/stable_mir/convert/mod.rs @@ -0,0 +1,126 @@ +use std::ops::RangeInclusive; + +use rustc_smir::Tables; +use rustc_smir::context::SmirCtxt; + +use super::compiler_interface::BridgeTys; +use crate::rustc_smir; + +mod internal; +mod stable; + +impl<'tcx, T> Stable<'tcx> for &T +where + T: Stable<'tcx>, +{ + type T = T::T; + + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + (*self).stable(tables, cx) + } +} + +impl<'tcx, T> Stable<'tcx> for Option +where + T: Stable<'tcx>, +{ + type T = Option; + + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + self.as_ref().map(|value| value.stable(tables, cx)) + } +} + +impl<'tcx, T, E> Stable<'tcx> for Result +where + T: Stable<'tcx>, + E: Stable<'tcx>, +{ + type T = Result; + + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + match self { + Ok(val) => Ok(val.stable(tables, cx)), + Err(error) => Err(error.stable(tables, cx)), + } + } +} + +impl<'tcx, T> Stable<'tcx> for &[T] +where + T: Stable<'tcx>, +{ + type T = Vec; + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + self.iter().map(|e| e.stable(tables, cx)).collect() + } +} + +impl<'tcx, T, U> Stable<'tcx> for (T, U) +where + T: Stable<'tcx>, + U: Stable<'tcx>, +{ + type T = (T::T, U::T); + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + (self.0.stable(tables, cx), self.1.stable(tables, cx)) + } +} + +impl<'tcx, T> Stable<'tcx> for RangeInclusive +where + T: Stable<'tcx>, +{ + type T = RangeInclusive; + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + RangeInclusive::new(self.start().stable(tables, cx), self.end().stable(tables, cx)) + } +} + +/// Trait used to convert between an internal MIR type to a Stable MIR type. +pub trait Stable<'tcx> { + /// The stable representation of the type implementing Stable. + type T; + /// Converts an object to the equivalent Stable MIR representation. + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T; +} + +/// Trait used to translate a stable construct to its rustc counterpart. +/// +/// This is basically a mirror of [Stable]. +pub trait RustcInternal { + type T<'tcx>; + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T<'tcx>; +} diff --git a/compiler/rustc_smir/src/rustc_smir/convert/abi.rs b/compiler/rustc_smir/src/stable_mir/convert/stable/abi.rs similarity index 69% rename from compiler/rustc_smir/src/rustc_smir/convert/abi.rs rename to compiler/rustc_smir/src/stable_mir/convert/stable/abi.rs index 35d5b7fb89afd..b6f02e1bc8f6b 100644 --- a/compiler/rustc_smir/src/rustc_smir/convert/abi.rs +++ b/compiler/rustc_smir/src/stable_mir/convert/stable/abi.rs @@ -4,22 +4,25 @@ use rustc_abi::{ArmCall, CanonAbi, InterruptKind, X86Call}; use rustc_middle::ty; +use rustc_smir::context::SmirCtxt; +use rustc_smir::{IndexedVal, Tables}; use rustc_target::callconv; use stable_mir::abi::{ AddressSpace, ArgAbi, CallConvention, FieldsShape, FloatLength, FnAbi, IntegerLength, IntegerType, Layout, LayoutShape, PassMode, Primitive, ReprFlags, ReprOptions, Scalar, TagEncoding, TyAndLayout, ValueAbi, VariantsShape, WrappingRange, }; +use stable_mir::compiler_interface::BridgeTys; +use stable_mir::convert::Stable; use stable_mir::opaque; use stable_mir::target::MachineSize as Size; -use stable_mir::ty::{Align, IndexedVal, VariantIdx}; +use stable_mir::ty::{Align, VariantIdx}; -use crate::rustc_smir::{Stable, Tables}; -use crate::stable_mir; +use crate::{rustc_smir, stable_mir}; impl<'tcx> Stable<'tcx> for rustc_abi::VariantIdx { type T = VariantIdx; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { VariantIdx::to_val(self.as_usize()) } } @@ -27,7 +30,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::VariantIdx { impl<'tcx> Stable<'tcx> for rustc_abi::Endian { type T = stable_mir::target::Endian; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { rustc_abi::Endian::Little => stable_mir::target::Endian::Little, rustc_abi::Endian::Big => stable_mir::target::Endian::Big, @@ -38,29 +41,41 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Endian { impl<'tcx> Stable<'tcx> for rustc_abi::TyAndLayout<'tcx, ty::Ty<'tcx>> { type T = TyAndLayout; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - TyAndLayout { ty: self.ty.stable(tables), layout: self.layout.stable(tables) } + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + TyAndLayout { ty: self.ty.stable(tables, cx), layout: self.layout.stable(tables, cx) } } } impl<'tcx> Stable<'tcx> for rustc_abi::Layout<'tcx> { type T = Layout; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - tables.layout_id(tables.tcx.lift(*self).unwrap()) + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + tables.layout_id(cx.lift(*self).unwrap()) } } impl<'tcx> Stable<'tcx> for rustc_abi::LayoutData { type T = LayoutShape; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { LayoutShape { - fields: self.fields.stable(tables), - variants: self.variants.stable(tables), - abi: self.backend_repr.stable(tables), - abi_align: self.align.abi.stable(tables), - size: self.size.stable(tables), + fields: self.fields.stable(tables, cx), + variants: self.variants.stable(tables, cx), + abi: self.backend_repr.stable(tables, cx), + abi_align: self.align.abi.stable(tables, cx), + size: self.size.stable(tables, cx), } } } @@ -68,14 +83,18 @@ impl<'tcx> Stable<'tcx> for rustc_abi::LayoutData Stable<'tcx> for callconv::FnAbi<'tcx, ty::Ty<'tcx>> { type T = FnAbi; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { assert!(self.args.len() >= self.fixed_count as usize); assert!(!self.c_variadic || matches!(self.conv, CanonAbi::C)); FnAbi { - args: self.args.as_ref().stable(tables), - ret: self.ret.stable(tables), + args: self.args.as_ref().stable(tables, cx), + ret: self.ret.stable(tables, cx), fixed_count: self.fixed_count, - conv: self.conv.stable(tables), + conv: self.conv.stable(tables, cx), c_variadic: self.c_variadic, } } @@ -84,11 +103,15 @@ impl<'tcx> Stable<'tcx> for callconv::FnAbi<'tcx, ty::Ty<'tcx>> { impl<'tcx> Stable<'tcx> for callconv::ArgAbi<'tcx, ty::Ty<'tcx>> { type T = ArgAbi; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { ArgAbi { - ty: self.layout.ty.stable(tables), - layout: self.layout.layout.stable(tables), - mode: self.mode.stable(tables), + ty: self.layout.ty.stable(tables, cx), + layout: self.layout.layout.stable(tables, cx), + mode: self.mode.stable(tables, cx), } } } @@ -96,7 +119,7 @@ impl<'tcx> Stable<'tcx> for callconv::ArgAbi<'tcx, ty::Ty<'tcx>> { impl<'tcx> Stable<'tcx> for CanonAbi { type T = CallConvention; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { CanonAbi::C => CallConvention::C, CanonAbi::Rust => CallConvention::Rust, @@ -132,7 +155,7 @@ impl<'tcx> Stable<'tcx> for CanonAbi { impl<'tcx> Stable<'tcx> for callconv::PassMode { type T = PassMode; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { callconv::PassMode::Ignore => PassMode::Ignore, callconv::PassMode::Direct(attr) => PassMode::Direct(opaque(attr)), @@ -154,15 +177,19 @@ impl<'tcx> Stable<'tcx> for callconv::PassMode { impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape { type T = FieldsShape; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match self { rustc_abi::FieldsShape::Primitive => FieldsShape::Primitive, rustc_abi::FieldsShape::Union(count) => FieldsShape::Union(*count), rustc_abi::FieldsShape::Array { stride, count } => { - FieldsShape::Array { stride: stride.stable(tables), count: *count } + FieldsShape::Array { stride: stride.stable(tables, cx), count: *count } } rustc_abi::FieldsShape::Arbitrary { offsets, .. } => { - FieldsShape::Arbitrary { offsets: offsets.iter().as_slice().stable(tables) } + FieldsShape::Arbitrary { offsets: offsets.iter().as_slice().stable(tables, cx) } } } } @@ -171,18 +198,22 @@ impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape { impl<'tcx> Stable<'tcx> for rustc_abi::Variants { type T = VariantsShape; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match self { rustc_abi::Variants::Single { index } => { - VariantsShape::Single { index: index.stable(tables) } + VariantsShape::Single { index: index.stable(tables, cx) } } rustc_abi::Variants::Empty => VariantsShape::Empty, rustc_abi::Variants::Multiple { tag, tag_encoding, tag_field, variants } => { VariantsShape::Multiple { - tag: tag.stable(tables), - tag_encoding: tag_encoding.stable(tables), - tag_field: tag_field.stable(tables), - variants: variants.iter().as_slice().stable(tables), + tag: tag.stable(tables, cx), + tag_encoding: tag_encoding.stable(tables, cx), + tag_field: *tag_field, + variants: variants.iter().as_slice().stable(tables, cx), } } } @@ -192,13 +223,17 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Variants Stable<'tcx> for rustc_abi::TagEncoding { type T = TagEncoding; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match self { rustc_abi::TagEncoding::Direct => TagEncoding::Direct, rustc_abi::TagEncoding::Niche { untagged_variant, niche_variants, niche_start } => { TagEncoding::Niche { - untagged_variant: untagged_variant.stable(tables), - niche_variants: niche_variants.stable(tables), + untagged_variant: untagged_variant.stable(tables, cx), + niche_variants: niche_variants.stable(tables, cx), niche_start: *niche_start, } } @@ -209,14 +244,18 @@ impl<'tcx> Stable<'tcx> for rustc_abi::TagEncoding { impl<'tcx> Stable<'tcx> for rustc_abi::BackendRepr { type T = ValueAbi; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match *self { - rustc_abi::BackendRepr::Scalar(scalar) => ValueAbi::Scalar(scalar.stable(tables)), + rustc_abi::BackendRepr::Scalar(scalar) => ValueAbi::Scalar(scalar.stable(tables, cx)), rustc_abi::BackendRepr::ScalarPair(first, second) => { - ValueAbi::ScalarPair(first.stable(tables), second.stable(tables)) + ValueAbi::ScalarPair(first.stable(tables, cx), second.stable(tables, cx)) } rustc_abi::BackendRepr::SimdVector { element, count } => { - ValueAbi::Vector { element: element.stable(tables), count } + ValueAbi::Vector { element: element.stable(tables, cx), count } } rustc_abi::BackendRepr::Memory { sized } => ValueAbi::Aggregate { sized }, } @@ -226,7 +265,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::BackendRepr { impl<'tcx> Stable<'tcx> for rustc_abi::Size { type T = Size; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { Size::from_bits(self.bits_usize()) } } @@ -234,7 +273,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Size { impl<'tcx> Stable<'tcx> for rustc_abi::Align { type T = Align; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { self.bytes() } } @@ -242,13 +281,17 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Align { impl<'tcx> Stable<'tcx> for rustc_abi::Scalar { type T = Scalar; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match self { rustc_abi::Scalar::Initialized { value, valid_range } => Scalar::Initialized { - value: value.stable(tables), - valid_range: valid_range.stable(tables), + value: value.stable(tables, cx), + valid_range: valid_range.stable(tables, cx), }, - rustc_abi::Scalar::Union { value } => Scalar::Union { value: value.stable(tables) }, + rustc_abi::Scalar::Union { value } => Scalar::Union { value: value.stable(tables, cx) }, } } } @@ -256,15 +299,19 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Scalar { impl<'tcx> Stable<'tcx> for rustc_abi::Primitive { type T = Primitive; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match self { rustc_abi::Primitive::Int(length, signed) => { - Primitive::Int { length: length.stable(tables), signed: *signed } + Primitive::Int { length: length.stable(tables, cx), signed: *signed } } rustc_abi::Primitive::Float(length) => { - Primitive::Float { length: length.stable(tables) } + Primitive::Float { length: length.stable(tables, cx) } } - rustc_abi::Primitive::Pointer(space) => Primitive::Pointer(space.stable(tables)), + rustc_abi::Primitive::Pointer(space) => Primitive::Pointer(space.stable(tables, cx)), } } } @@ -272,7 +319,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Primitive { impl<'tcx> Stable<'tcx> for rustc_abi::AddressSpace { type T = AddressSpace; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { AddressSpace(self.0) } } @@ -280,7 +327,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::AddressSpace { impl<'tcx> Stable<'tcx> for rustc_abi::Integer { type T = IntegerLength; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { rustc_abi::Integer::I8 => IntegerLength::I8, rustc_abi::Integer::I16 => IntegerLength::I16, @@ -294,7 +341,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Integer { impl<'tcx> Stable<'tcx> for rustc_abi::Float { type T = FloatLength; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { rustc_abi::Float::F16 => FloatLength::F16, rustc_abi::Float::F32 => FloatLength::F32, @@ -307,7 +354,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Float { impl<'tcx> Stable<'tcx> for rustc_abi::WrappingRange { type T = WrappingRange; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { WrappingRange { start: self.start, end: self.end } } } diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs b/compiler/rustc_smir/src/stable_mir/convert/stable/mir.rs similarity index 68% rename from compiler/rustc_smir/src/rustc_smir/convert/mir.rs rename to compiler/rustc_smir/src/stable_mir/convert/stable/mir.rs index 42b3e59b73ab9..34c6663c63cae 100644 --- a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs +++ b/compiler/rustc_smir/src/stable_mir/convert/stable/mir.rs @@ -1,56 +1,66 @@ //! Conversion of internal Rust compiler `mir` items to stable ones. -use rustc_middle::mir::interpret::alloc_range; use rustc_middle::mir::mono::MonoItem; use rustc_middle::{bug, mir}; +use rustc_smir::context::SmirCtxt; +use rustc_smir::{SmirError, Tables}; +use stable_mir::compiler_interface::BridgeTys; +use stable_mir::convert::Stable; use stable_mir::mir::alloc::GlobalAlloc; use stable_mir::mir::{ConstOperand, Statement, UserTypeProjection, VarDebugInfoFragment}; use stable_mir::ty::{Allocation, ConstantKind, MirConst}; -use stable_mir::{Error, opaque}; +use stable_mir::{Error, alloc, opaque}; -use crate::rustc_smir::{Stable, Tables, alloc}; -use crate::stable_mir; +use crate::{rustc_smir, stable_mir}; impl<'tcx> Stable<'tcx> for mir::Body<'tcx> { type T = stable_mir::mir::Body; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { stable_mir::mir::Body::new( self.basic_blocks .iter() .map(|block| stable_mir::mir::BasicBlock { - terminator: block.terminator().stable(tables), + terminator: block.terminator().stable(tables, cx), statements: block .statements .iter() - .map(|statement| statement.stable(tables)) + .map(|statement| statement.stable(tables, cx)) .collect(), }) .collect(), self.local_decls .iter() .map(|decl| stable_mir::mir::LocalDecl { - ty: decl.ty.stable(tables), - span: decl.source_info.span.stable(tables), - mutability: decl.mutability.stable(tables), + ty: decl.ty.stable(tables, cx), + span: decl.source_info.span.stable(tables, cx), + mutability: decl.mutability.stable(tables, cx), }) .collect(), self.arg_count, - self.var_debug_info.iter().map(|info| info.stable(tables)).collect(), - self.spread_arg.stable(tables), - self.span.stable(tables), + self.var_debug_info.iter().map(|info| info.stable(tables, cx)).collect(), + self.spread_arg.stable(tables, cx), + self.span.stable(tables, cx), ) } } impl<'tcx> Stable<'tcx> for mir::VarDebugInfo<'tcx> { type T = stable_mir::mir::VarDebugInfo; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { stable_mir::mir::VarDebugInfo { name: self.name.to_string(), - source_info: self.source_info.stable(tables), - composite: self.composite.as_ref().map(|composite| composite.stable(tables)), - value: self.value.stable(tables), + source_info: self.source_info.stable(tables, cx), + composite: self.composite.as_ref().map(|composite| composite.stable(tables, cx)), + value: self.value.stable(tables, cx), argument_index: self.argument_index, } } @@ -58,40 +68,59 @@ impl<'tcx> Stable<'tcx> for mir::VarDebugInfo<'tcx> { impl<'tcx> Stable<'tcx> for mir::Statement<'tcx> { type T = stable_mir::mir::Statement; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - Statement { kind: self.kind.stable(tables), span: self.source_info.span.stable(tables) } + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + Statement { + kind: self.kind.stable(tables, cx), + span: self.source_info.span.stable(tables, cx), + } } } impl<'tcx> Stable<'tcx> for mir::SourceInfo { type T = stable_mir::mir::SourceInfo; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - stable_mir::mir::SourceInfo { span: self.span.stable(tables), scope: self.scope.into() } + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + stable_mir::mir::SourceInfo { span: self.span.stable(tables, cx), scope: self.scope.into() } } } impl<'tcx> Stable<'tcx> for mir::VarDebugInfoFragment<'tcx> { type T = stable_mir::mir::VarDebugInfoFragment; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { VarDebugInfoFragment { - ty: self.ty.stable(tables), - projection: self.projection.iter().map(|e| e.stable(tables)).collect(), + ty: self.ty.stable(tables, cx), + projection: self.projection.iter().map(|e| e.stable(tables, cx)).collect(), } } } impl<'tcx> Stable<'tcx> for mir::VarDebugInfoContents<'tcx> { type T = stable_mir::mir::VarDebugInfoContents; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match self { mir::VarDebugInfoContents::Place(place) => { - stable_mir::mir::VarDebugInfoContents::Place(place.stable(tables)) + stable_mir::mir::VarDebugInfoContents::Place(place.stable(tables, cx)) } mir::VarDebugInfoContents::Const(const_operand) => { let op = ConstOperand { - span: const_operand.span.stable(tables), + span: const_operand.span.stable(tables, cx), user_ty: const_operand.user_ty.map(|index| index.as_usize()), - const_: const_operand.const_.stable(tables), + const_: const_operand.const_.stable(tables, cx), }; stable_mir::mir::VarDebugInfoContents::Const(op) } @@ -101,53 +130,58 @@ impl<'tcx> Stable<'tcx> for mir::VarDebugInfoContents<'tcx> { impl<'tcx> Stable<'tcx> for mir::StatementKind<'tcx> { type T = stable_mir::mir::StatementKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match self { mir::StatementKind::Assign(assign) => stable_mir::mir::StatementKind::Assign( - assign.0.stable(tables), - assign.1.stable(tables), + assign.0.stable(tables, cx), + assign.1.stable(tables, cx), ), mir::StatementKind::FakeRead(fake_read_place) => { stable_mir::mir::StatementKind::FakeRead( - fake_read_place.0.stable(tables), - fake_read_place.1.stable(tables), + fake_read_place.0.stable(tables, cx), + fake_read_place.1.stable(tables, cx), ) } mir::StatementKind::SetDiscriminant { place, variant_index } => { stable_mir::mir::StatementKind::SetDiscriminant { - place: place.as_ref().stable(tables), - variant_index: variant_index.stable(tables), + place: place.as_ref().stable(tables, cx), + variant_index: variant_index.stable(tables, cx), } } mir::StatementKind::Deinit(place) => { - stable_mir::mir::StatementKind::Deinit(place.stable(tables)) + stable_mir::mir::StatementKind::Deinit(place.stable(tables, cx)) } mir::StatementKind::StorageLive(place) => { - stable_mir::mir::StatementKind::StorageLive(place.stable(tables)) + stable_mir::mir::StatementKind::StorageLive(place.stable(tables, cx)) } mir::StatementKind::StorageDead(place) => { - stable_mir::mir::StatementKind::StorageDead(place.stable(tables)) - } - mir::StatementKind::Retag(retag, place) => { - stable_mir::mir::StatementKind::Retag(retag.stable(tables), place.stable(tables)) + stable_mir::mir::StatementKind::StorageDead(place.stable(tables, cx)) } + mir::StatementKind::Retag(retag, place) => stable_mir::mir::StatementKind::Retag( + retag.stable(tables, cx), + place.stable(tables, cx), + ), mir::StatementKind::PlaceMention(place) => { - stable_mir::mir::StatementKind::PlaceMention(place.stable(tables)) + stable_mir::mir::StatementKind::PlaceMention(place.stable(tables, cx)) } mir::StatementKind::AscribeUserType(place_projection, variance) => { stable_mir::mir::StatementKind::AscribeUserType { - place: place_projection.as_ref().0.stable(tables), - projections: place_projection.as_ref().1.stable(tables), - variance: variance.stable(tables), + place: place_projection.as_ref().0.stable(tables, cx), + projections: place_projection.as_ref().1.stable(tables, cx), + variance: variance.stable(tables, cx), } } mir::StatementKind::Coverage(coverage) => { stable_mir::mir::StatementKind::Coverage(opaque(coverage)) } mir::StatementKind::Intrinsic(intrinstic) => { - stable_mir::mir::StatementKind::Intrinsic(intrinstic.stable(tables)) + stable_mir::mir::StatementKind::Intrinsic(intrinstic.stable(tables, cx)) } mir::StatementKind::ConstEvalCounter => { stable_mir::mir::StatementKind::ConstEvalCounter @@ -163,61 +197,68 @@ impl<'tcx> Stable<'tcx> for mir::StatementKind<'tcx> { impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> { type T = stable_mir::mir::Rvalue; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::mir::Rvalue::*; match self { - Use(op) => stable_mir::mir::Rvalue::Use(op.stable(tables)), + Use(op) => stable_mir::mir::Rvalue::Use(op.stable(tables, cx)), Repeat(op, len) => { - let len = len.stable(tables); - stable_mir::mir::Rvalue::Repeat(op.stable(tables), len) + let len = len.stable(tables, cx); + stable_mir::mir::Rvalue::Repeat(op.stable(tables, cx), len) } Ref(region, kind, place) => stable_mir::mir::Rvalue::Ref( - region.stable(tables), - kind.stable(tables), - place.stable(tables), + region.stable(tables, cx), + kind.stable(tables, cx), + place.stable(tables, cx), ), ThreadLocalRef(def_id) => { stable_mir::mir::Rvalue::ThreadLocalRef(tables.crate_item(*def_id)) } - RawPtr(mutability, place) => { - stable_mir::mir::Rvalue::AddressOf(mutability.stable(tables), place.stable(tables)) - } - Len(place) => stable_mir::mir::Rvalue::Len(place.stable(tables)), + RawPtr(mutability, place) => stable_mir::mir::Rvalue::AddressOf( + mutability.stable(tables, cx), + place.stable(tables, cx), + ), + Len(place) => stable_mir::mir::Rvalue::Len(place.stable(tables, cx)), Cast(cast_kind, op, ty) => stable_mir::mir::Rvalue::Cast( - cast_kind.stable(tables), - op.stable(tables), - ty.stable(tables), + cast_kind.stable(tables, cx), + op.stable(tables, cx), + ty.stable(tables, cx), ), BinaryOp(bin_op, ops) => { if let Some(bin_op) = bin_op.overflowing_to_wrapping() { stable_mir::mir::Rvalue::CheckedBinaryOp( - bin_op.stable(tables), - ops.0.stable(tables), - ops.1.stable(tables), + bin_op.stable(tables, cx), + ops.0.stable(tables, cx), + ops.1.stable(tables, cx), ) } else { stable_mir::mir::Rvalue::BinaryOp( - bin_op.stable(tables), - ops.0.stable(tables), - ops.1.stable(tables), + bin_op.stable(tables, cx), + ops.0.stable(tables, cx), + ops.1.stable(tables, cx), ) } } - NullaryOp(null_op, ty) => { - stable_mir::mir::Rvalue::NullaryOp(null_op.stable(tables), ty.stable(tables)) - } + NullaryOp(null_op, ty) => stable_mir::mir::Rvalue::NullaryOp( + null_op.stable(tables, cx), + ty.stable(tables, cx), + ), UnaryOp(un_op, op) => { - stable_mir::mir::Rvalue::UnaryOp(un_op.stable(tables), op.stable(tables)) + stable_mir::mir::Rvalue::UnaryOp(un_op.stable(tables, cx), op.stable(tables, cx)) } - Discriminant(place) => stable_mir::mir::Rvalue::Discriminant(place.stable(tables)), + Discriminant(place) => stable_mir::mir::Rvalue::Discriminant(place.stable(tables, cx)), Aggregate(agg_kind, operands) => { - let operands = operands.iter().map(|op| op.stable(tables)).collect(); - stable_mir::mir::Rvalue::Aggregate(agg_kind.stable(tables), operands) + let operands = operands.iter().map(|op| op.stable(tables, cx)).collect(); + stable_mir::mir::Rvalue::Aggregate(agg_kind.stable(tables, cx), operands) } - ShallowInitBox(op, ty) => { - stable_mir::mir::Rvalue::ShallowInitBox(op.stable(tables), ty.stable(tables)) - } - CopyForDeref(place) => stable_mir::mir::Rvalue::CopyForDeref(place.stable(tables)), + ShallowInitBox(op, ty) => stable_mir::mir::Rvalue::ShallowInitBox( + op.stable(tables, cx), + ty.stable(tables, cx), + ), + CopyForDeref(place) => stable_mir::mir::Rvalue::CopyForDeref(place.stable(tables, cx)), WrapUnsafeBinder(..) => todo!("FIXME(unsafe_binders):"), } } @@ -225,7 +266,7 @@ impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> { impl<'tcx> Stable<'tcx> for mir::Mutability { type T = stable_mir::mir::Mutability; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_hir::Mutability::*; match *self { Not => stable_mir::mir::Mutability::Not, @@ -236,7 +277,7 @@ impl<'tcx> Stable<'tcx> for mir::Mutability { impl<'tcx> Stable<'tcx> for mir::RawPtrKind { type T = stable_mir::mir::RawPtrKind; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use mir::RawPtrKind::*; match *self { Const => stable_mir::mir::RawPtrKind::Const, @@ -248,19 +289,23 @@ impl<'tcx> Stable<'tcx> for mir::RawPtrKind { impl<'tcx> Stable<'tcx> for mir::BorrowKind { type T = stable_mir::mir::BorrowKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::mir::BorrowKind::*; match *self { Shared => stable_mir::mir::BorrowKind::Shared, - Fake(kind) => stable_mir::mir::BorrowKind::Fake(kind.stable(tables)), - Mut { kind } => stable_mir::mir::BorrowKind::Mut { kind: kind.stable(tables) }, + Fake(kind) => stable_mir::mir::BorrowKind::Fake(kind.stable(tables, cx)), + Mut { kind } => stable_mir::mir::BorrowKind::Mut { kind: kind.stable(tables, cx) }, } } } impl<'tcx> Stable<'tcx> for mir::MutBorrowKind { type T = stable_mir::mir::MutBorrowKind; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::mir::MutBorrowKind::*; match *self { Default => stable_mir::mir::MutBorrowKind::Default, @@ -272,7 +317,7 @@ impl<'tcx> Stable<'tcx> for mir::MutBorrowKind { impl<'tcx> Stable<'tcx> for mir::FakeBorrowKind { type T = stable_mir::mir::FakeBorrowKind; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::mir::FakeBorrowKind::*; match *self { Deep => stable_mir::mir::FakeBorrowKind::Deep, @@ -283,13 +328,17 @@ impl<'tcx> Stable<'tcx> for mir::FakeBorrowKind { impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> { type T = stable_mir::mir::NullOp; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::mir::NullOp::*; match self { SizeOf => stable_mir::mir::NullOp::SizeOf, AlignOf => stable_mir::mir::NullOp::AlignOf, OffsetOf(indices) => stable_mir::mir::NullOp::OffsetOf( - indices.iter().map(|idx| idx.stable(tables)).collect(), + indices.iter().map(|idx| idx.stable(tables, cx)).collect(), ), UbChecks => stable_mir::mir::NullOp::UbChecks, ContractChecks => stable_mir::mir::NullOp::ContractChecks, @@ -299,14 +348,20 @@ impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> { impl<'tcx> Stable<'tcx> for mir::CastKind { type T = stable_mir::mir::CastKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::mir::CastKind::*; use rustc_middle::ty::adjustment::PointerCoercion; match self { PointerExposeProvenance => stable_mir::mir::CastKind::PointerExposeAddress, PointerWithExposedProvenance => stable_mir::mir::CastKind::PointerWithExposedProvenance, PointerCoercion(PointerCoercion::DynStar, _) => stable_mir::mir::CastKind::DynStar, - PointerCoercion(c, _) => stable_mir::mir::CastKind::PointerCoercion(c.stable(tables)), + PointerCoercion(c, _) => { + stable_mir::mir::CastKind::PointerCoercion(c.stable(tables, cx)) + } IntToInt => stable_mir::mir::CastKind::IntToInt, FloatToInt => stable_mir::mir::CastKind::FloatToInt, FloatToFloat => stable_mir::mir::CastKind::FloatToFloat, @@ -320,7 +375,7 @@ impl<'tcx> Stable<'tcx> for mir::CastKind { impl<'tcx> Stable<'tcx> for mir::FakeReadCause { type T = stable_mir::mir::FakeReadCause; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::mir::FakeReadCause::*; match self { ForMatchGuard => stable_mir::mir::FakeReadCause::ForMatchGuard, @@ -336,12 +391,16 @@ impl<'tcx> Stable<'tcx> for mir::FakeReadCause { impl<'tcx> Stable<'tcx> for mir::Operand<'tcx> { type T = stable_mir::mir::Operand; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::mir::Operand::*; match self { - Copy(place) => stable_mir::mir::Operand::Copy(place.stable(tables)), - Move(place) => stable_mir::mir::Operand::Move(place.stable(tables)), - Constant(c) => stable_mir::mir::Operand::Constant(c.stable(tables)), + Copy(place) => stable_mir::mir::Operand::Copy(place.stable(tables, cx)), + Move(place) => stable_mir::mir::Operand::Move(place.stable(tables, cx)), + Constant(c) => stable_mir::mir::Operand::Constant(c.stable(tables, cx)), } } } @@ -349,35 +408,48 @@ impl<'tcx> Stable<'tcx> for mir::Operand<'tcx> { impl<'tcx> Stable<'tcx> for mir::ConstOperand<'tcx> { type T = stable_mir::mir::ConstOperand; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { stable_mir::mir::ConstOperand { - span: self.span.stable(tables), + span: self.span.stable(tables, cx), user_ty: self.user_ty.map(|u| u.as_usize()).or(None), - const_: self.const_.stable(tables), + const_: self.const_.stable(tables, cx), } } } impl<'tcx> Stable<'tcx> for mir::Place<'tcx> { type T = stable_mir::mir::Place; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { stable_mir::mir::Place { local: self.local.as_usize(), - projection: self.projection.iter().map(|e| e.stable(tables)).collect(), + projection: self.projection.iter().map(|e| e.stable(tables, cx)).collect(), } } } impl<'tcx> Stable<'tcx> for mir::PlaceElem<'tcx> { type T = stable_mir::mir::ProjectionElem; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::mir::ProjectionElem::*; match self { Deref => stable_mir::mir::ProjectionElem::Deref, - Field(idx, ty) => { - stable_mir::mir::ProjectionElem::Field(idx.stable(tables), ty.stable(tables)) - } - Index(local) => stable_mir::mir::ProjectionElem::Index(local.stable(tables)), + Field(idx, ty) => stable_mir::mir::ProjectionElem::Field( + idx.stable(tables, cx), + ty.stable(tables, cx), + ), + Index(local) => stable_mir::mir::ProjectionElem::Index(local.stable(tables, cx)), ConstantIndex { offset, min_length, from_end } => { stable_mir::mir::ProjectionElem::ConstantIndex { offset: *offset, @@ -395,9 +467,9 @@ impl<'tcx> Stable<'tcx> for mir::PlaceElem<'tcx> { // via a lookup using the `VariantIdx`. The `Option` argument is therefore // dropped when converting to Stable MIR. A brief justification for this decision can be // found at https://github.com/rust-lang/rust/pull/117517#issuecomment-1811683486 - Downcast(_, idx) => stable_mir::mir::ProjectionElem::Downcast(idx.stable(tables)), - OpaqueCast(ty) => stable_mir::mir::ProjectionElem::OpaqueCast(ty.stable(tables)), - Subtype(ty) => stable_mir::mir::ProjectionElem::Subtype(ty.stable(tables)), + Downcast(_, idx) => stable_mir::mir::ProjectionElem::Downcast(idx.stable(tables, cx)), + OpaqueCast(ty) => stable_mir::mir::ProjectionElem::OpaqueCast(ty.stable(tables, cx)), + Subtype(ty) => stable_mir::mir::ProjectionElem::Subtype(ty.stable(tables, cx)), UnwrapUnsafeBinder(..) => todo!("FIXME(unsafe_binders):"), } } @@ -406,21 +478,21 @@ impl<'tcx> Stable<'tcx> for mir::PlaceElem<'tcx> { impl<'tcx> Stable<'tcx> for mir::UserTypeProjection { type T = stable_mir::mir::UserTypeProjection; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { UserTypeProjection { base: self.base.as_usize(), projection: opaque(&self.projs) } } } impl<'tcx> Stable<'tcx> for mir::Local { type T = stable_mir::mir::Local; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { self.as_usize() } } impl<'tcx> Stable<'tcx> for mir::RetagKind { type T = stable_mir::mir::RetagKind; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::mir::RetagKind; match self { RetagKind::FnEntry => stable_mir::mir::RetagKind::FnEntry, @@ -433,7 +505,7 @@ impl<'tcx> Stable<'tcx> for mir::RetagKind { impl<'tcx> Stable<'tcx> for mir::UnwindAction { type T = stable_mir::mir::UnwindAction; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::mir::UnwindAction; match self { UnwindAction::Continue => stable_mir::mir::UnwindAction::Continue, @@ -447,18 +519,22 @@ impl<'tcx> Stable<'tcx> for mir::UnwindAction { impl<'tcx> Stable<'tcx> for mir::NonDivergingIntrinsic<'tcx> { type T = stable_mir::mir::NonDivergingIntrinsic; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::mir::NonDivergingIntrinsic; use stable_mir::mir::CopyNonOverlapping; match self { NonDivergingIntrinsic::Assume(op) => { - stable_mir::mir::NonDivergingIntrinsic::Assume(op.stable(tables)) + stable_mir::mir::NonDivergingIntrinsic::Assume(op.stable(tables, cx)) } NonDivergingIntrinsic::CopyNonOverlapping(copy_non_overlapping) => { stable_mir::mir::NonDivergingIntrinsic::CopyNonOverlapping(CopyNonOverlapping { - src: copy_non_overlapping.src.stable(tables), - dst: copy_non_overlapping.dst.stable(tables), - count: copy_non_overlapping.count.stable(tables), + src: copy_non_overlapping.src.stable(tables, cx), + dst: copy_non_overlapping.dst.stable(tables, cx), + count: copy_non_overlapping.count.stable(tables, cx), }) } } @@ -467,40 +543,44 @@ impl<'tcx> Stable<'tcx> for mir::NonDivergingIntrinsic<'tcx> { impl<'tcx> Stable<'tcx> for mir::AssertMessage<'tcx> { type T = stable_mir::mir::AssertMessage; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::mir::AssertKind; match self { AssertKind::BoundsCheck { len, index } => stable_mir::mir::AssertMessage::BoundsCheck { - len: len.stable(tables), - index: index.stable(tables), + len: len.stable(tables, cx), + index: index.stable(tables, cx), }, AssertKind::Overflow(bin_op, op1, op2) => stable_mir::mir::AssertMessage::Overflow( - bin_op.stable(tables), - op1.stable(tables), - op2.stable(tables), + bin_op.stable(tables, cx), + op1.stable(tables, cx), + op2.stable(tables, cx), ), AssertKind::OverflowNeg(op) => { - stable_mir::mir::AssertMessage::OverflowNeg(op.stable(tables)) + stable_mir::mir::AssertMessage::OverflowNeg(op.stable(tables, cx)) } AssertKind::DivisionByZero(op) => { - stable_mir::mir::AssertMessage::DivisionByZero(op.stable(tables)) + stable_mir::mir::AssertMessage::DivisionByZero(op.stable(tables, cx)) } AssertKind::RemainderByZero(op) => { - stable_mir::mir::AssertMessage::RemainderByZero(op.stable(tables)) + stable_mir::mir::AssertMessage::RemainderByZero(op.stable(tables, cx)) } AssertKind::ResumedAfterReturn(coroutine) => { - stable_mir::mir::AssertMessage::ResumedAfterReturn(coroutine.stable(tables)) + stable_mir::mir::AssertMessage::ResumedAfterReturn(coroutine.stable(tables, cx)) } AssertKind::ResumedAfterPanic(coroutine) => { - stable_mir::mir::AssertMessage::ResumedAfterPanic(coroutine.stable(tables)) + stable_mir::mir::AssertMessage::ResumedAfterPanic(coroutine.stable(tables, cx)) } AssertKind::ResumedAfterDrop(coroutine) => { - stable_mir::mir::AssertMessage::ResumedAfterDrop(coroutine.stable(tables)) + stable_mir::mir::AssertMessage::ResumedAfterDrop(coroutine.stable(tables, cx)) } AssertKind::MisalignedPointerDereference { required, found } => { stable_mir::mir::AssertMessage::MisalignedPointerDereference { - required: required.stable(tables), - found: found.stable(tables), + required: required.stable(tables, cx), + found: found.stable(tables, cx), } } AssertKind::NullPointerDereference => { @@ -512,7 +592,7 @@ impl<'tcx> Stable<'tcx> for mir::AssertMessage<'tcx> { impl<'tcx> Stable<'tcx> for mir::BinOp { type T = stable_mir::mir::BinOp; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::mir::BinOp; match self { BinOp::Add => stable_mir::mir::BinOp::Add, @@ -547,7 +627,7 @@ impl<'tcx> Stable<'tcx> for mir::BinOp { impl<'tcx> Stable<'tcx> for mir::UnOp { type T = stable_mir::mir::UnOp; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::mir::UnOp; match self { UnOp::Not => stable_mir::mir::UnOp::Not, @@ -559,17 +639,21 @@ impl<'tcx> Stable<'tcx> for mir::UnOp { impl<'tcx> Stable<'tcx> for mir::AggregateKind<'tcx> { type T = stable_mir::mir::AggregateKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match self { mir::AggregateKind::Array(ty) => { - stable_mir::mir::AggregateKind::Array(ty.stable(tables)) + stable_mir::mir::AggregateKind::Array(ty.stable(tables, cx)) } mir::AggregateKind::Tuple => stable_mir::mir::AggregateKind::Tuple, mir::AggregateKind::Adt(def_id, var_idx, generic_arg, user_ty_index, field_idx) => { stable_mir::mir::AggregateKind::Adt( tables.adt_def(*def_id), - var_idx.stable(tables), - generic_arg.stable(tables), + var_idx.stable(tables, cx), + generic_arg.stable(tables, cx), user_ty_index.map(|idx| idx.index()), field_idx.map(|idx| idx.index()), ) @@ -577,39 +661,46 @@ impl<'tcx> Stable<'tcx> for mir::AggregateKind<'tcx> { mir::AggregateKind::Closure(def_id, generic_arg) => { stable_mir::mir::AggregateKind::Closure( tables.closure_def(*def_id), - generic_arg.stable(tables), + generic_arg.stable(tables, cx), ) } mir::AggregateKind::Coroutine(def_id, generic_arg) => { stable_mir::mir::AggregateKind::Coroutine( tables.coroutine_def(*def_id), - generic_arg.stable(tables), - tables.tcx.coroutine_movability(*def_id).stable(tables), + generic_arg.stable(tables, cx), + cx.coroutine_movability(*def_id).stable(tables, cx), ) } mir::AggregateKind::CoroutineClosure(def_id, generic_args) => { stable_mir::mir::AggregateKind::CoroutineClosure( tables.coroutine_closure_def(*def_id), - generic_args.stable(tables), + generic_args.stable(tables, cx), ) } - mir::AggregateKind::RawPtr(ty, mutability) => { - stable_mir::mir::AggregateKind::RawPtr(ty.stable(tables), mutability.stable(tables)) - } + mir::AggregateKind::RawPtr(ty, mutability) => stable_mir::mir::AggregateKind::RawPtr( + ty.stable(tables, cx), + mutability.stable(tables, cx), + ), } } } impl<'tcx> Stable<'tcx> for mir::InlineAsmOperand<'tcx> { type T = stable_mir::mir::InlineAsmOperand; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::mir::InlineAsmOperand; let (in_value, out_place) = match self { - InlineAsmOperand::In { value, .. } => (Some(value.stable(tables)), None), - InlineAsmOperand::Out { place, .. } => (None, place.map(|place| place.stable(tables))), + InlineAsmOperand::In { value, .. } => (Some(value.stable(tables, cx)), None), + InlineAsmOperand::Out { place, .. } => { + (None, place.map(|place| place.stable(tables, cx))) + } InlineAsmOperand::InOut { in_value, out_place, .. } => { - (Some(in_value.stable(tables)), out_place.map(|place| place.stable(tables))) + (Some(in_value.stable(tables, cx)), out_place.map(|place| place.stable(tables, cx))) } InlineAsmOperand::Const { .. } | InlineAsmOperand::SymFn { .. } @@ -623,22 +714,33 @@ impl<'tcx> Stable<'tcx> for mir::InlineAsmOperand<'tcx> { impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> { type T = stable_mir::mir::Terminator; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::mir::Terminator; - Terminator { kind: self.kind.stable(tables), span: self.source_info.span.stable(tables) } + Terminator { + kind: self.kind.stable(tables, cx), + span: self.source_info.span.stable(tables, cx), + } } } impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> { type T = stable_mir::mir::TerminatorKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::mir::TerminatorKind; match self { mir::TerminatorKind::Goto { target } => { TerminatorKind::Goto { target: target.as_usize() } } mir::TerminatorKind::SwitchInt { discr, targets } => TerminatorKind::SwitchInt { - discr: discr.stable(tables), + discr: discr.stable(tables, cx), targets: { let branches = targets.iter().map(|(val, target)| (val, target.as_usize())); stable_mir::mir::SwitchTargets::new( @@ -659,9 +761,9 @@ impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> { drop: _, async_fut: _, } => TerminatorKind::Drop { - place: place.stable(tables), + place: place.stable(tables, cx), target: target.as_usize(), - unwind: unwind.stable(tables), + unwind: unwind.stable(tables, cx), }, mir::TerminatorKind::Call { func, @@ -672,20 +774,20 @@ impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> { call_source: _, fn_span: _, } => TerminatorKind::Call { - func: func.stable(tables), - args: args.iter().map(|arg| arg.node.stable(tables)).collect(), - destination: destination.stable(tables), + func: func.stable(tables, cx), + args: args.iter().map(|arg| arg.node.stable(tables, cx)).collect(), + destination: destination.stable(tables, cx), target: target.map(|t| t.as_usize()), - unwind: unwind.stable(tables), + unwind: unwind.stable(tables, cx), }, mir::TerminatorKind::TailCall { func: _, args: _, fn_span: _ } => todo!(), mir::TerminatorKind::Assert { cond, expected, msg, target, unwind } => { TerminatorKind::Assert { - cond: cond.stable(tables), + cond: cond.stable(tables, cx), expected: *expected, - msg: msg.stable(tables), + msg: msg.stable(tables, cx), target: target.as_usize(), - unwind: unwind.stable(tables), + unwind: unwind.stable(tables, cx), } } mir::TerminatorKind::InlineAsm { @@ -698,12 +800,12 @@ impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> { unwind, } => TerminatorKind::InlineAsm { template: format!("{template:?}"), - operands: operands.iter().map(|operand| operand.stable(tables)).collect(), + operands: operands.iter().map(|operand| operand.stable(tables, cx)).collect(), options: format!("{options:?}"), line_spans: format!("{line_spans:?}"), // FIXME: Figure out how to do labels in SMIR destination: targets.first().map(|d| d.as_usize()), - unwind: unwind.stable(tables), + unwind: unwind.stable(tables, cx), }, mir::TerminatorKind::Yield { .. } | mir::TerminatorKind::CoroutineDrop @@ -716,22 +818,40 @@ impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> { impl<'tcx> Stable<'tcx> for mir::interpret::ConstAllocation<'tcx> { type T = Allocation; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - self.inner().stable(tables) + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + self.inner().stable(tables, cx) } } impl<'tcx> Stable<'tcx> for mir::interpret::Allocation { type T = stable_mir::ty::Allocation; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - alloc::allocation_filter(self, alloc_range(rustc_abi::Size::ZERO, self.size()), tables) + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + use rustc_smir::context::SmirAllocRange; + alloc::allocation_filter( + self, + cx.alloc_range(rustc_abi::Size::ZERO, self.size()), + tables, + cx, + ) } } impl<'tcx> Stable<'tcx> for mir::interpret::AllocId { type T = stable_mir::mir::alloc::AllocId; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + _: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { tables.create_alloc_id(*self) } } @@ -739,19 +859,25 @@ impl<'tcx> Stable<'tcx> for mir::interpret::AllocId { impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> { type T = GlobalAlloc; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match self { mir::interpret::GlobalAlloc::Function { instance, .. } => { - GlobalAlloc::Function(instance.stable(tables)) + GlobalAlloc::Function(instance.stable(tables, cx)) } mir::interpret::GlobalAlloc::VTable(ty, dyn_ty) => { // FIXME: Should we record the whole vtable? - GlobalAlloc::VTable(ty.stable(tables), dyn_ty.principal().stable(tables)) + GlobalAlloc::VTable(ty.stable(tables, cx), dyn_ty.principal().stable(tables, cx)) } mir::interpret::GlobalAlloc::Static(def) => { GlobalAlloc::Static(tables.static_def(*def)) } - mir::interpret::GlobalAlloc::Memory(alloc) => GlobalAlloc::Memory(alloc.stable(tables)), + mir::interpret::GlobalAlloc::Memory(alloc) => { + GlobalAlloc::Memory(alloc.stable(tables, cx)) + } } } } @@ -759,33 +885,37 @@ impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> { impl<'tcx> Stable<'tcx> for rustc_middle::mir::Const<'tcx> { type T = stable_mir::ty::MirConst; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - let id = tables.intern_mir_const(tables.tcx.lift(*self).unwrap()); + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + let id = tables.intern_mir_const(cx.lift(*self).unwrap()); match *self { mir::Const::Ty(ty, c) => MirConst::new( - stable_mir::ty::ConstantKind::Ty(c.stable(tables)), - ty.stable(tables), + stable_mir::ty::ConstantKind::Ty(c.stable(tables, cx)), + ty.stable(tables, cx), id, ), mir::Const::Unevaluated(unev_const, ty) => { let kind = stable_mir::ty::ConstantKind::Unevaluated(stable_mir::ty::UnevaluatedConst { def: tables.const_def(unev_const.def), - args: unev_const.args.stable(tables), + args: unev_const.args.stable(tables, cx), promoted: unev_const.promoted.map(|u| u.as_u32()), }); - let ty = ty.stable(tables); + let ty = ty.stable(tables, cx); MirConst::new(kind, ty, id) } mir::Const::Val(mir::ConstValue::ZeroSized, ty) => { - let ty = ty.stable(tables); + let ty = ty.stable(tables, cx); MirConst::new(ConstantKind::ZeroSized, ty, id) } mir::Const::Val(val, ty) => { - let ty = tables.tcx.lift(ty).unwrap(); - let val = tables.tcx.lift(val).unwrap(); - let kind = ConstantKind::Allocated(alloc::new_allocation(ty, val, tables)); - let ty = ty.stable(tables); + let ty = cx.lift(ty).unwrap(); + let val = cx.lift(val).unwrap(); + let kind = ConstantKind::Allocated(alloc::new_allocation(ty, val, tables, cx)); + let ty = ty.stable(tables, cx); MirConst::new(kind, ty, id) } } @@ -795,7 +925,7 @@ impl<'tcx> Stable<'tcx> for rustc_middle::mir::Const<'tcx> { impl<'tcx> Stable<'tcx> for mir::interpret::ErrorHandled { type T = Error; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { Error::new(format!("{self:?}")) } } @@ -803,10 +933,14 @@ impl<'tcx> Stable<'tcx> for mir::interpret::ErrorHandled { impl<'tcx> Stable<'tcx> for MonoItem<'tcx> { type T = stable_mir::mir::mono::MonoItem; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::mir::mono::MonoItem as StableMonoItem; match self { - MonoItem::Fn(instance) => StableMonoItem::Fn(instance.stable(tables)), + MonoItem::Fn(instance) => StableMonoItem::Fn(instance.stable(tables, cx)), MonoItem::Static(def_id) => StableMonoItem::Static(tables.static_def(*def_id)), MonoItem::GlobalAsm(item_id) => StableMonoItem::GlobalAsm(opaque(item_id)), } diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mod.rs b/compiler/rustc_smir/src/stable_mir/convert/stable/mod.rs similarity index 68% rename from compiler/rustc_smir/src/rustc_smir/convert/mod.rs rename to compiler/rustc_smir/src/stable_mir/convert/stable/mod.rs index 3494de62d835b..1cead1c3c37bc 100644 --- a/compiler/rustc_smir/src/rustc_smir/convert/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/convert/stable/mod.rs @@ -1,18 +1,20 @@ //! Conversion of internal Rust compiler items to stable ones. use rustc_abi::FieldIdx; +use rustc_smir::Tables; +use rustc_smir::context::SmirCtxt; +use stable_mir::compiler_interface::BridgeTys; -use crate::rustc_smir::{Stable, Tables}; -use crate::stable_mir; +use super::Stable; +use crate::{rustc_smir, stable_mir}; mod abi; -mod error; mod mir; mod ty; impl<'tcx> Stable<'tcx> for rustc_hir::Safety { type T = stable_mir::mir::Safety; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { rustc_hir::Safety::Unsafe => stable_mir::mir::Safety::Unsafe, rustc_hir::Safety::Safe => stable_mir::mir::Safety::Safe, @@ -22,14 +24,14 @@ impl<'tcx> Stable<'tcx> for rustc_hir::Safety { impl<'tcx> Stable<'tcx> for FieldIdx { type T = usize; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { self.as_usize() } } impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineSource { type T = stable_mir::mir::CoroutineSource; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_hir::CoroutineSource; match self { CoroutineSource::Block => stable_mir::mir::CoroutineSource::Block, @@ -41,28 +43,32 @@ impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineSource { impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineKind { type T = stable_mir::mir::CoroutineKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_hir::{CoroutineDesugaring, CoroutineKind}; match *self { CoroutineKind::Desugared(CoroutineDesugaring::Async, source) => { stable_mir::mir::CoroutineKind::Desugared( stable_mir::mir::CoroutineDesugaring::Async, - source.stable(tables), + source.stable(tables, cx), ) } CoroutineKind::Desugared(CoroutineDesugaring::Gen, source) => { stable_mir::mir::CoroutineKind::Desugared( stable_mir::mir::CoroutineDesugaring::Gen, - source.stable(tables), + source.stable(tables, cx), ) } CoroutineKind::Coroutine(movability) => { - stable_mir::mir::CoroutineKind::Coroutine(movability.stable(tables)) + stable_mir::mir::CoroutineKind::Coroutine(movability.stable(tables, cx)) } CoroutineKind::Desugared(CoroutineDesugaring::AsyncGen, source) => { stable_mir::mir::CoroutineKind::Desugared( stable_mir::mir::CoroutineDesugaring::AsyncGen, - source.stable(tables), + source.stable(tables, cx), ) } } @@ -72,7 +78,7 @@ impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineKind { impl<'tcx> Stable<'tcx> for rustc_span::Symbol { type T = stable_mir::Symbol; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { self.to_string() } } @@ -80,7 +86,11 @@ impl<'tcx> Stable<'tcx> for rustc_span::Symbol { impl<'tcx> Stable<'tcx> for rustc_span::Span { type T = stable_mir::ty::Span; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + _: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { tables.create_span(*self) } } diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/stable_mir/convert/stable/ty.rs similarity index 69% rename from compiler/rustc_smir/src/rustc_smir/convert/ty.rs rename to compiler/rustc_smir/src/stable_mir/convert/stable/ty.rs index b4239ddd896ec..89df7e2fdc5d5 100644 --- a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs +++ b/compiler/rustc_smir/src/stable_mir/convert/stable/ty.rs @@ -2,16 +2,20 @@ use rustc_middle::ty::Ty; use rustc_middle::{mir, ty}; +use rustc_smir::Tables; +use rustc_smir::context::SmirCtxt; +use stable_mir::alloc; +use stable_mir::compiler_interface::BridgeTys; +use stable_mir::convert::Stable; use stable_mir::ty::{ AdtKind, FloatTy, GenericArgs, GenericParamDef, IntTy, Region, RigidTy, TyKind, UintTy, }; -use crate::rustc_smir::{Stable, Tables, alloc}; -use crate::stable_mir; +use crate::{rustc_smir, stable_mir}; impl<'tcx> Stable<'tcx> for ty::AliasTyKind { type T = stable_mir::ty::AliasKind; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { ty::Projection => stable_mir::ty::AliasKind::Projection, ty::Inherent => stable_mir::ty::AliasKind::Inherent, @@ -23,24 +27,35 @@ impl<'tcx> Stable<'tcx> for ty::AliasTyKind { impl<'tcx> Stable<'tcx> for ty::AliasTy<'tcx> { type T = stable_mir::ty::AliasTy; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { let ty::AliasTy { args, def_id, .. } = self; - stable_mir::ty::AliasTy { def_id: tables.alias_def(*def_id), args: args.stable(tables) } + stable_mir::ty::AliasTy { def_id: tables.alias_def(*def_id), args: args.stable(tables, cx) } } } impl<'tcx> Stable<'tcx> for ty::AliasTerm<'tcx> { type T = stable_mir::ty::AliasTerm; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { let ty::AliasTerm { args, def_id, .. } = self; - stable_mir::ty::AliasTerm { def_id: tables.alias_def(*def_id), args: args.stable(tables) } + stable_mir::ty::AliasTerm { + def_id: tables.alias_def(*def_id), + args: args.stable(tables, cx), + } } } impl<'tcx> Stable<'tcx> for ty::DynKind { type T = stable_mir::ty::DynKind; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { ty::Dyn => stable_mir::ty::DynKind::Dyn, ty::DynStar => stable_mir::ty::DynKind::DynStar, @@ -51,14 +66,18 @@ impl<'tcx> Stable<'tcx> for ty::DynKind { impl<'tcx> Stable<'tcx> for ty::ExistentialPredicate<'tcx> { type T = stable_mir::ty::ExistentialPredicate; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::ExistentialPredicate::*; match self { ty::ExistentialPredicate::Trait(existential_trait_ref) => { - Trait(existential_trait_ref.stable(tables)) + Trait(existential_trait_ref.stable(tables, cx)) } ty::ExistentialPredicate::Projection(existential_projection) => { - Projection(existential_projection.stable(tables)) + Projection(existential_projection.stable(tables, cx)) } ty::ExistentialPredicate::AutoTrait(def_id) => AutoTrait(tables.trait_def(*def_id)), } @@ -68,11 +87,15 @@ impl<'tcx> Stable<'tcx> for ty::ExistentialPredicate<'tcx> { impl<'tcx> Stable<'tcx> for ty::ExistentialTraitRef<'tcx> { type T = stable_mir::ty::ExistentialTraitRef; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { let ty::ExistentialTraitRef { def_id, args, .. } = self; stable_mir::ty::ExistentialTraitRef { def_id: tables.trait_def(*def_id), - generic_args: args.stable(tables), + generic_args: args.stable(tables, cx), } } } @@ -80,12 +103,16 @@ impl<'tcx> Stable<'tcx> for ty::ExistentialTraitRef<'tcx> { impl<'tcx> Stable<'tcx> for ty::TermKind<'tcx> { type T = stable_mir::ty::TermKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::TermKind; match self { - ty::TermKind::Ty(ty) => TermKind::Type(ty.stable(tables)), + ty::TermKind::Ty(ty) => TermKind::Type(ty.stable(tables, cx)), ty::TermKind::Const(cnst) => { - let cnst = cnst.stable(tables); + let cnst = cnst.stable(tables, cx); TermKind::Const(cnst) } } @@ -95,25 +122,33 @@ impl<'tcx> Stable<'tcx> for ty::TermKind<'tcx> { impl<'tcx> Stable<'tcx> for ty::ExistentialProjection<'tcx> { type T = stable_mir::ty::ExistentialProjection; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { let ty::ExistentialProjection { def_id, args, term, .. } = self; stable_mir::ty::ExistentialProjection { def_id: tables.trait_def(*def_id), - generic_args: args.stable(tables), - term: term.kind().stable(tables), + generic_args: args.stable(tables, cx), + term: term.kind().stable(tables, cx), } } } impl<'tcx> Stable<'tcx> for ty::adjustment::PointerCoercion { type T = stable_mir::mir::PointerCoercion; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::ty::adjustment::PointerCoercion; match self { PointerCoercion::ReifyFnPointer => stable_mir::mir::PointerCoercion::ReifyFnPointer, PointerCoercion::UnsafeFnPointer => stable_mir::mir::PointerCoercion::UnsafeFnPointer, PointerCoercion::ClosureFnPointer(safety) => { - stable_mir::mir::PointerCoercion::ClosureFnPointer(safety.stable(tables)) + stable_mir::mir::PointerCoercion::ClosureFnPointer(safety.stable(tables, cx)) } PointerCoercion::MutToConstPointer => { stable_mir::mir::PointerCoercion::MutToConstPointer @@ -127,7 +162,7 @@ impl<'tcx> Stable<'tcx> for ty::adjustment::PointerCoercion { impl<'tcx> Stable<'tcx> for ty::UserTypeAnnotationIndex { type T = usize; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { self.as_usize() } } @@ -135,7 +170,7 @@ impl<'tcx> Stable<'tcx> for ty::UserTypeAnnotationIndex { impl<'tcx> Stable<'tcx> for ty::AdtKind { type T = AdtKind; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { ty::AdtKind::Struct => AdtKind::Struct, ty::AdtKind::Union => AdtKind::Union, @@ -147,30 +182,44 @@ impl<'tcx> Stable<'tcx> for ty::AdtKind { impl<'tcx> Stable<'tcx> for ty::FieldDef { type T = stable_mir::ty::FieldDef; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { stable_mir::ty::FieldDef { def: tables.create_def_id(self.did), - name: self.name.stable(tables), + name: self.name.stable(tables, cx), } } } impl<'tcx> Stable<'tcx> for ty::GenericArgs<'tcx> { type T = stable_mir::ty::GenericArgs; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - GenericArgs(self.iter().map(|arg| arg.kind().stable(tables)).collect()) + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + GenericArgs(self.iter().map(|arg| arg.kind().stable(tables, cx)).collect()) } } impl<'tcx> Stable<'tcx> for ty::GenericArgKind<'tcx> { type T = stable_mir::ty::GenericArgKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::GenericArgKind; match self { - ty::GenericArgKind::Lifetime(region) => GenericArgKind::Lifetime(region.stable(tables)), - ty::GenericArgKind::Type(ty) => GenericArgKind::Type(ty.stable(tables)), - ty::GenericArgKind::Const(cnst) => GenericArgKind::Const(cnst.stable(tables)), + ty::GenericArgKind::Lifetime(region) => { + GenericArgKind::Lifetime(region.stable(tables, cx)) + } + ty::GenericArgKind::Type(ty) => GenericArgKind::Type(ty.stable(tables, cx)), + ty::GenericArgKind::Const(cnst) => GenericArgKind::Const(cnst.stable(tables, cx)), } } } @@ -181,15 +230,19 @@ where { type T = stable_mir::ty::Binder; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::Binder; Binder { - value: self.as_ref().skip_binder().stable(tables), + value: self.as_ref().skip_binder().stable(tables, cx), bound_vars: self .bound_vars() .iter() - .map(|bound_var| bound_var.stable(tables)) + .map(|bound_var| bound_var.stable(tables, cx)) .collect(), } } @@ -201,23 +254,35 @@ where { type T = stable_mir::ty::EarlyBinder; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::EarlyBinder; - EarlyBinder { value: self.as_ref().skip_binder().stable(tables) } + EarlyBinder { value: self.as_ref().skip_binder().stable(tables, cx) } } } impl<'tcx> Stable<'tcx> for ty::FnSig<'tcx> { type T = stable_mir::ty::FnSig; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::FnSig; FnSig { - inputs_and_output: self.inputs_and_output.iter().map(|ty| ty.stable(tables)).collect(), + inputs_and_output: self + .inputs_and_output + .iter() + .map(|ty| ty.stable(tables, cx)) + .collect(), c_variadic: self.c_variadic, - safety: self.safety.stable(tables), - abi: self.abi.stable(tables), + safety: self.safety.stable(tables, cx), + abi: self.abi.stable(tables, cx), } } } @@ -225,7 +290,11 @@ impl<'tcx> Stable<'tcx> for ty::FnSig<'tcx> { impl<'tcx> Stable<'tcx> for ty::BoundTyKind { type T = stable_mir::ty::BoundTyKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + _: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::BoundTyKind; match self { @@ -240,7 +309,11 @@ impl<'tcx> Stable<'tcx> for ty::BoundTyKind { impl<'tcx> Stable<'tcx> for ty::BoundRegionKind { type T = stable_mir::ty::BoundRegionKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + _: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::BoundRegionKind; match self { @@ -256,15 +329,19 @@ impl<'tcx> Stable<'tcx> for ty::BoundRegionKind { impl<'tcx> Stable<'tcx> for ty::BoundVariableKind { type T = stable_mir::ty::BoundVariableKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::BoundVariableKind; match self { ty::BoundVariableKind::Ty(bound_ty_kind) => { - BoundVariableKind::Ty(bound_ty_kind.stable(tables)) + BoundVariableKind::Ty(bound_ty_kind.stable(tables, cx)) } ty::BoundVariableKind::Region(bound_region_kind) => { - BoundVariableKind::Region(bound_region_kind.stable(tables)) + BoundVariableKind::Region(bound_region_kind.stable(tables, cx)) } ty::BoundVariableKind::Const => BoundVariableKind::Const, } @@ -274,7 +351,7 @@ impl<'tcx> Stable<'tcx> for ty::BoundVariableKind { impl<'tcx> Stable<'tcx> for ty::IntTy { type T = IntTy; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { ty::IntTy::Isize => IntTy::Isize, ty::IntTy::I8 => IntTy::I8, @@ -289,7 +366,7 @@ impl<'tcx> Stable<'tcx> for ty::IntTy { impl<'tcx> Stable<'tcx> for ty::UintTy { type T = UintTy; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { ty::UintTy::Usize => UintTy::Usize, ty::UintTy::U8 => UintTy::U8, @@ -304,7 +381,7 @@ impl<'tcx> Stable<'tcx> for ty::UintTy { impl<'tcx> Stable<'tcx> for ty::FloatTy { type T = FloatTy; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { ty::FloatTy::F16 => FloatTy::F16, ty::FloatTy::F32 => FloatTy::F32, @@ -316,46 +393,55 @@ impl<'tcx> Stable<'tcx> for ty::FloatTy { impl<'tcx> Stable<'tcx> for Ty<'tcx> { type T = stable_mir::ty::Ty; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - tables.intern_ty(tables.tcx.lift(*self).unwrap()) + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + tables.intern_ty(cx.lift(*self).unwrap()) } } impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> { type T = stable_mir::ty::TyKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match self { ty::Bool => TyKind::RigidTy(RigidTy::Bool), ty::Char => TyKind::RigidTy(RigidTy::Char), - ty::Int(int_ty) => TyKind::RigidTy(RigidTy::Int(int_ty.stable(tables))), - ty::Uint(uint_ty) => TyKind::RigidTy(RigidTy::Uint(uint_ty.stable(tables))), - ty::Float(float_ty) => TyKind::RigidTy(RigidTy::Float(float_ty.stable(tables))), + ty::Int(int_ty) => TyKind::RigidTy(RigidTy::Int(int_ty.stable(tables, cx))), + ty::Uint(uint_ty) => TyKind::RigidTy(RigidTy::Uint(uint_ty.stable(tables, cx))), + ty::Float(float_ty) => TyKind::RigidTy(RigidTy::Float(float_ty.stable(tables, cx))), ty::Adt(adt_def, generic_args) => TyKind::RigidTy(RigidTy::Adt( tables.adt_def(adt_def.did()), - generic_args.stable(tables), + generic_args.stable(tables, cx), )), ty::Foreign(def_id) => TyKind::RigidTy(RigidTy::Foreign(tables.foreign_def(*def_id))), ty::Str => TyKind::RigidTy(RigidTy::Str), ty::Array(ty, constant) => { - TyKind::RigidTy(RigidTy::Array(ty.stable(tables), constant.stable(tables))) + TyKind::RigidTy(RigidTy::Array(ty.stable(tables, cx), constant.stable(tables, cx))) } ty::Pat(ty, pat) => { - TyKind::RigidTy(RigidTy::Pat(ty.stable(tables), pat.stable(tables))) + TyKind::RigidTy(RigidTy::Pat(ty.stable(tables, cx), pat.stable(tables, cx))) } - ty::Slice(ty) => TyKind::RigidTy(RigidTy::Slice(ty.stable(tables))), + ty::Slice(ty) => TyKind::RigidTy(RigidTy::Slice(ty.stable(tables, cx))), ty::RawPtr(ty, mutbl) => { - TyKind::RigidTy(RigidTy::RawPtr(ty.stable(tables), mutbl.stable(tables))) + TyKind::RigidTy(RigidTy::RawPtr(ty.stable(tables, cx), mutbl.stable(tables, cx))) } ty::Ref(region, ty, mutbl) => TyKind::RigidTy(RigidTy::Ref( - region.stable(tables), - ty.stable(tables), - mutbl.stable(tables), + region.stable(tables, cx), + ty.stable(tables, cx), + mutbl.stable(tables, cx), + )), + ty::FnDef(def_id, generic_args) => TyKind::RigidTy(RigidTy::FnDef( + tables.fn_def(*def_id), + generic_args.stable(tables, cx), )), - ty::FnDef(def_id, generic_args) => { - TyKind::RigidTy(RigidTy::FnDef(tables.fn_def(*def_id), generic_args.stable(tables))) - } ty::FnPtr(sig_tys, hdr) => { - TyKind::RigidTy(RigidTy::FnPtr(sig_tys.with(*hdr).stable(tables))) + TyKind::RigidTy(RigidTy::FnPtr(sig_tys.with(*hdr).stable(tables, cx))) } // FIXME(unsafe_binders): ty::UnsafeBinder(_) => todo!(), @@ -363,36 +449,36 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> { TyKind::RigidTy(RigidTy::Dynamic( existential_predicates .iter() - .map(|existential_predicate| existential_predicate.stable(tables)) + .map(|existential_predicate| existential_predicate.stable(tables, cx)) .collect(), - region.stable(tables), - dyn_kind.stable(tables), + region.stable(tables, cx), + dyn_kind.stable(tables, cx), )) } ty::Closure(def_id, generic_args) => TyKind::RigidTy(RigidTy::Closure( tables.closure_def(*def_id), - generic_args.stable(tables), + generic_args.stable(tables, cx), )), ty::CoroutineClosure(..) => todo!("FIXME(async_closures): Lower these to SMIR"), ty::Coroutine(def_id, generic_args) => TyKind::RigidTy(RigidTy::Coroutine( tables.coroutine_def(*def_id), - generic_args.stable(tables), - tables.tcx.coroutine_movability(*def_id).stable(tables), + generic_args.stable(tables, cx), + cx.coroutine_movability(*def_id).stable(tables, cx), )), ty::Never => TyKind::RigidTy(RigidTy::Never), - ty::Tuple(fields) => { - TyKind::RigidTy(RigidTy::Tuple(fields.iter().map(|ty| ty.stable(tables)).collect())) - } + ty::Tuple(fields) => TyKind::RigidTy(RigidTy::Tuple( + fields.iter().map(|ty| ty.stable(tables, cx)).collect(), + )), ty::Alias(alias_kind, alias_ty) => { - TyKind::Alias(alias_kind.stable(tables), alias_ty.stable(tables)) + TyKind::Alias(alias_kind.stable(tables, cx), alias_ty.stable(tables, cx)) } - ty::Param(param_ty) => TyKind::Param(param_ty.stable(tables)), + ty::Param(param_ty) => TyKind::Param(param_ty.stable(tables, cx)), ty::Bound(debruijn_idx, bound_ty) => { - TyKind::Bound(debruijn_idx.as_usize(), bound_ty.stable(tables)) + TyKind::Bound(debruijn_idx.as_usize(), bound_ty.stable(tables, cx)) } ty::CoroutineWitness(def_id, args) => TyKind::RigidTy(RigidTy::CoroutineWitness( tables.coroutine_witness_def(*def_id), - args.stable(tables), + args.stable(tables, cx), )), ty::Placeholder(..) | ty::Infer(_) | ty::Error(_) => { unreachable!(); @@ -404,12 +490,16 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> { impl<'tcx> Stable<'tcx> for ty::Pattern<'tcx> { type T = stable_mir::ty::Pattern; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { match **self { ty::PatternKind::Range { start, end } => stable_mir::ty::Pattern::Range { // FIXME(SMIR): update data structures to not have an Option here anymore - start: Some(start.stable(tables)), - end: Some(end.stable(tables)), + start: Some(start.stable(tables, cx)), + end: Some(end.stable(tables, cx)), include_end: true, }, ty::PatternKind::Or(_) => todo!(), @@ -420,24 +510,30 @@ impl<'tcx> Stable<'tcx> for ty::Pattern<'tcx> { impl<'tcx> Stable<'tcx> for ty::Const<'tcx> { type T = stable_mir::ty::TyConst; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - let ct = tables.tcx.lift(*self).unwrap(); + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + let ct = cx.lift(*self).unwrap(); let kind = match ct.kind() { ty::ConstKind::Value(cv) => { - let const_val = tables.tcx.valtree_to_const_val(cv); + let const_val = cx.valtree_to_const_val(cv); if matches!(const_val, mir::ConstValue::ZeroSized) { - stable_mir::ty::TyConstKind::ZSTValue(cv.ty.stable(tables)) + stable_mir::ty::TyConstKind::ZSTValue(cv.ty.stable(tables, cx)) } else { stable_mir::ty::TyConstKind::Value( - cv.ty.stable(tables), - alloc::new_allocation(cv.ty, const_val, tables), + cv.ty.stable(tables, cx), + alloc::new_allocation(cv.ty, const_val, tables, cx), ) } } - ty::ConstKind::Param(param) => stable_mir::ty::TyConstKind::Param(param.stable(tables)), + ty::ConstKind::Param(param) => { + stable_mir::ty::TyConstKind::Param(param.stable(tables, cx)) + } ty::ConstKind::Unevaluated(uv) => stable_mir::ty::TyConstKind::Unevaluated( tables.const_def(uv.def), - uv.args.stable(tables), + uv.args.stable(tables, cx), ), ty::ConstKind::Error(_) => unreachable!(), ty::ConstKind::Infer(_) => unreachable!(), @@ -452,7 +548,7 @@ impl<'tcx> Stable<'tcx> for ty::Const<'tcx> { impl<'tcx> Stable<'tcx> for ty::ParamConst { type T = stable_mir::ty::ParamConst; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use stable_mir::ty::ParamConst; ParamConst { index: self.index, name: self.name.to_string() } } @@ -460,7 +556,7 @@ impl<'tcx> Stable<'tcx> for ty::ParamConst { impl<'tcx> Stable<'tcx> for ty::ParamTy { type T = stable_mir::ty::ParamTy; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use stable_mir::ty::ParamTy; ParamTy { index: self.index, name: self.name.to_string() } } @@ -468,15 +564,19 @@ impl<'tcx> Stable<'tcx> for ty::ParamTy { impl<'tcx> Stable<'tcx> for ty::BoundTy { type T = stable_mir::ty::BoundTy; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::BoundTy; - BoundTy { var: self.var.as_usize(), kind: self.kind.stable(tables) } + BoundTy { var: self.var.as_usize(), kind: self.kind.stable(tables, cx) } } } impl<'tcx> Stable<'tcx> for ty::trait_def::TraitSpecializationKind { type T = stable_mir::ty::TraitSpecializationKind; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use stable_mir::ty::TraitSpecializationKind; match self { @@ -491,20 +591,24 @@ impl<'tcx> Stable<'tcx> for ty::trait_def::TraitSpecializationKind { impl<'tcx> Stable<'tcx> for ty::TraitDef { type T = stable_mir::ty::TraitDecl; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::opaque; use stable_mir::ty::TraitDecl; TraitDecl { def_id: tables.trait_def(self.def_id), - safety: self.safety.stable(tables), + safety: self.safety.stable(tables, cx), paren_sugar: self.paren_sugar, has_auto_impl: self.has_auto_impl, is_marker: self.is_marker, is_coinductive: self.is_coinductive, skip_array_during_method_dispatch: self.skip_array_during_method_dispatch, skip_boxed_slice_during_method_dispatch: self.skip_boxed_slice_during_method_dispatch, - specialization_kind: self.specialization_kind.stable(tables), + specialization_kind: self.specialization_kind.stable(tables, cx), must_implement_one_of: self .must_implement_one_of .as_ref() @@ -517,20 +621,28 @@ impl<'tcx> Stable<'tcx> for ty::TraitDef { impl<'tcx> Stable<'tcx> for ty::TraitRef<'tcx> { type T = stable_mir::ty::TraitRef; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::TraitRef; - TraitRef::try_new(tables.trait_def(self.def_id), self.args.stable(tables)).unwrap() + TraitRef::try_new(tables.trait_def(self.def_id), self.args.stable(tables, cx)).unwrap() } } impl<'tcx> Stable<'tcx> for ty::Generics { type T = stable_mir::ty::Generics; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::Generics; - let params: Vec<_> = self.own_params.iter().map(|param| param.stable(tables)).collect(); + let params: Vec<_> = self.own_params.iter().map(|param| param.stable(tables, cx)).collect(); let param_def_id_to_index = params.iter().map(|param| (param.def_id, param.index)).collect(); @@ -543,7 +655,7 @@ impl<'tcx> Stable<'tcx> for ty::Generics { has_late_bound_regions: self .has_late_bound_regions .as_ref() - .map(|late_bound_regions| late_bound_regions.stable(tables)), + .map(|late_bound_regions| late_bound_regions.stable(tables, cx)), } } } @@ -551,7 +663,7 @@ impl<'tcx> Stable<'tcx> for ty::Generics { impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDefKind { type T = stable_mir::ty::GenericParamDefKind; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use stable_mir::ty::GenericParamDefKind; match self { ty::GenericParamDefKind::Lifetime => GenericParamDefKind::Lifetime, @@ -568,13 +680,17 @@ impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDefKind { impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDef { type T = stable_mir::ty::GenericParamDef; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { GenericParamDef { name: self.name.to_string(), def_id: tables.generic_def(self.def_id), index: self.index, pure_wrt_drop: self.pure_wrt_drop, - kind: self.kind.stable(tables), + kind: self.kind.stable(tables, cx), } } } @@ -582,31 +698,36 @@ impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDef { impl<'tcx> Stable<'tcx> for ty::PredicateKind<'tcx> { type T = stable_mir::ty::PredicateKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::ty::PredicateKind; match self { PredicateKind::Clause(clause_kind) => { - stable_mir::ty::PredicateKind::Clause(clause_kind.stable(tables)) + stable_mir::ty::PredicateKind::Clause(clause_kind.stable(tables, cx)) } PredicateKind::DynCompatible(did) => { stable_mir::ty::PredicateKind::DynCompatible(tables.trait_def(*did)) } PredicateKind::Subtype(subtype_predicate) => { - stable_mir::ty::PredicateKind::SubType(subtype_predicate.stable(tables)) + stable_mir::ty::PredicateKind::SubType(subtype_predicate.stable(tables, cx)) } PredicateKind::Coerce(coerce_predicate) => { - stable_mir::ty::PredicateKind::Coerce(coerce_predicate.stable(tables)) - } - PredicateKind::ConstEquate(a, b) => { - stable_mir::ty::PredicateKind::ConstEquate(a.stable(tables), b.stable(tables)) + stable_mir::ty::PredicateKind::Coerce(coerce_predicate.stable(tables, cx)) } + PredicateKind::ConstEquate(a, b) => stable_mir::ty::PredicateKind::ConstEquate( + a.stable(tables, cx), + b.stable(tables, cx), + ), PredicateKind::Ambiguous => stable_mir::ty::PredicateKind::Ambiguous, PredicateKind::NormalizesTo(_pred) => unimplemented!(), PredicateKind::AliasRelate(a, b, alias_relation_direction) => { stable_mir::ty::PredicateKind::AliasRelate( - a.kind().stable(tables), - b.kind().stable(tables), - alias_relation_direction.stable(tables), + a.kind().stable(tables, cx), + b.kind().stable(tables, cx), + alias_relation_direction.stable(tables, cx), ) } } @@ -616,34 +737,38 @@ impl<'tcx> Stable<'tcx> for ty::PredicateKind<'tcx> { impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> { type T = stable_mir::ty::ClauseKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use rustc_middle::ty::ClauseKind; match *self { ClauseKind::Trait(trait_object) => { - stable_mir::ty::ClauseKind::Trait(trait_object.stable(tables)) + stable_mir::ty::ClauseKind::Trait(trait_object.stable(tables, cx)) } ClauseKind::RegionOutlives(region_outlives) => { - stable_mir::ty::ClauseKind::RegionOutlives(region_outlives.stable(tables)) + stable_mir::ty::ClauseKind::RegionOutlives(region_outlives.stable(tables, cx)) } ClauseKind::TypeOutlives(type_outlives) => { let ty::OutlivesPredicate::<_, _>(a, b) = type_outlives; stable_mir::ty::ClauseKind::TypeOutlives(stable_mir::ty::OutlivesPredicate( - a.stable(tables), - b.stable(tables), + a.stable(tables, cx), + b.stable(tables, cx), )) } ClauseKind::Projection(projection_predicate) => { - stable_mir::ty::ClauseKind::Projection(projection_predicate.stable(tables)) + stable_mir::ty::ClauseKind::Projection(projection_predicate.stable(tables, cx)) } ClauseKind::ConstArgHasType(const_, ty) => stable_mir::ty::ClauseKind::ConstArgHasType( - const_.stable(tables), - ty.stable(tables), + const_.stable(tables, cx), + ty.stable(tables, cx), ), ClauseKind::WellFormed(term) => { - stable_mir::ty::ClauseKind::WellFormed(term.kind().stable(tables)) + stable_mir::ty::ClauseKind::WellFormed(term.kind().stable(tables, cx)) } ClauseKind::ConstEvaluatable(const_) => { - stable_mir::ty::ClauseKind::ConstEvaluatable(const_.stable(tables)) + stable_mir::ty::ClauseKind::ConstEvaluatable(const_.stable(tables, cx)) } ClauseKind::HostEffect(..) => { todo!() @@ -655,7 +780,7 @@ impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> { impl<'tcx> Stable<'tcx> for ty::ClosureKind { type T = stable_mir::ty::ClosureKind; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::ty::ClosureKind::*; match self { Fn => stable_mir::ty::ClosureKind::Fn, @@ -668,25 +793,33 @@ impl<'tcx> Stable<'tcx> for ty::ClosureKind { impl<'tcx> Stable<'tcx> for ty::SubtypePredicate<'tcx> { type T = stable_mir::ty::SubtypePredicate; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { let ty::SubtypePredicate { a, b, a_is_expected: _ } = self; - stable_mir::ty::SubtypePredicate { a: a.stable(tables), b: b.stable(tables) } + stable_mir::ty::SubtypePredicate { a: a.stable(tables, cx), b: b.stable(tables, cx) } } } impl<'tcx> Stable<'tcx> for ty::CoercePredicate<'tcx> { type T = stable_mir::ty::CoercePredicate; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { let ty::CoercePredicate { a, b } = self; - stable_mir::ty::CoercePredicate { a: a.stable(tables), b: b.stable(tables) } + stable_mir::ty::CoercePredicate { a: a.stable(tables, cx), b: b.stable(tables, cx) } } } impl<'tcx> Stable<'tcx> for ty::AliasRelationDirection { type T = stable_mir::ty::AliasRelationDirection; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::ty::AliasRelationDirection::*; match self { Equate => stable_mir::ty::AliasRelationDirection::Equate, @@ -698,11 +831,15 @@ impl<'tcx> Stable<'tcx> for ty::AliasRelationDirection { impl<'tcx> Stable<'tcx> for ty::TraitPredicate<'tcx> { type T = stable_mir::ty::TraitPredicate; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { let ty::TraitPredicate { trait_ref, polarity } = self; stable_mir::ty::TraitPredicate { - trait_ref: trait_ref.stable(tables), - polarity: polarity.stable(tables), + trait_ref: trait_ref.stable(tables, cx), + polarity: polarity.stable(tables, cx), } } } @@ -713,20 +850,28 @@ where { type T = stable_mir::ty::OutlivesPredicate; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { let ty::OutlivesPredicate(a, b) = self; - stable_mir::ty::OutlivesPredicate(a.stable(tables), b.stable(tables)) + stable_mir::ty::OutlivesPredicate(a.stable(tables, cx), b.stable(tables, cx)) } } impl<'tcx> Stable<'tcx> for ty::ProjectionPredicate<'tcx> { type T = stable_mir::ty::ProjectionPredicate; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { let ty::ProjectionPredicate { projection_term, term } = self; stable_mir::ty::ProjectionPredicate { - projection_term: projection_term.stable(tables), - term: term.kind().stable(tables), + projection_term: projection_term.stable(tables, cx), + term: term.kind().stable(tables, cx), } } } @@ -734,7 +879,7 @@ impl<'tcx> Stable<'tcx> for ty::ProjectionPredicate<'tcx> { impl<'tcx> Stable<'tcx> for ty::ImplPolarity { type T = stable_mir::ty::ImplPolarity; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::ty::ImplPolarity::*; match self { Positive => stable_mir::ty::ImplPolarity::Positive, @@ -747,7 +892,7 @@ impl<'tcx> Stable<'tcx> for ty::ImplPolarity { impl<'tcx> Stable<'tcx> for ty::PredicatePolarity { type T = stable_mir::ty::PredicatePolarity; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_middle::ty::PredicatePolarity::*; match self { Positive => stable_mir::ty::PredicatePolarity::Positive, @@ -759,15 +904,23 @@ impl<'tcx> Stable<'tcx> for ty::PredicatePolarity { impl<'tcx> Stable<'tcx> for ty::Region<'tcx> { type T = stable_mir::ty::Region; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - Region { kind: self.kind().stable(tables) } + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + Region { kind: self.kind().stable(tables, cx) } } } impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> { type T = stable_mir::ty::RegionKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::{BoundRegion, EarlyParamRegion, RegionKind}; match self { ty::ReEarlyParam(early_reg) => RegionKind::ReEarlyParam(EarlyParamRegion { @@ -776,7 +929,10 @@ impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> { }), ty::ReBound(db_index, bound_reg) => RegionKind::ReBound( db_index.as_u32(), - BoundRegion { var: bound_reg.var.as_u32(), kind: bound_reg.kind.stable(tables) }, + BoundRegion { + var: bound_reg.var.as_u32(), + kind: bound_reg.kind.stable(tables, cx), + }, ), ty::ReStatic => RegionKind::ReStatic, ty::RePlaceholder(place_holder) => { @@ -784,7 +940,7 @@ impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> { universe: place_holder.universe.as_u32(), bound: BoundRegion { var: place_holder.bound.var.as_u32(), - kind: place_holder.bound.kind.stable(tables), + kind: place_holder.bound.kind.stable(tables, cx), }, }) } @@ -797,8 +953,12 @@ impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> { impl<'tcx> Stable<'tcx> for ty::Instance<'tcx> { type T = stable_mir::mir::mono::Instance; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - let def = tables.instance_def(tables.tcx.lift(*self).unwrap()); + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { + let def = tables.instance_def(cx.lift(*self).unwrap()); let kind = match self.def { ty::InstanceKind::Item(..) => stable_mir::mir::mono::InstanceKind::Item, ty::InstanceKind::Intrinsic(..) => stable_mir::mir::mono::InstanceKind::Intrinsic, @@ -826,7 +986,7 @@ impl<'tcx> Stable<'tcx> for ty::Instance<'tcx> { impl<'tcx> Stable<'tcx> for ty::Variance { type T = stable_mir::mir::Variance; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { ty::Bivariant => stable_mir::mir::Variance::Bivariant, ty::Contravariant => stable_mir::mir::Variance::Contravariant, @@ -839,7 +999,7 @@ impl<'tcx> Stable<'tcx> for ty::Variance { impl<'tcx> Stable<'tcx> for ty::Movability { type T = stable_mir::ty::Movability; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { match self { ty::Movability::Static => stable_mir::ty::Movability::Static, ty::Movability::Movable => stable_mir::ty::Movability::Movable, @@ -850,7 +1010,7 @@ impl<'tcx> Stable<'tcx> for ty::Movability { impl<'tcx> Stable<'tcx> for rustc_abi::ExternAbi { type T = stable_mir::ty::Abi; - fn stable(&self, _: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use rustc_abi::ExternAbi; use stable_mir::ty::Abi; match *self { @@ -887,10 +1047,14 @@ impl<'tcx> Stable<'tcx> for rustc_abi::ExternAbi { impl<'tcx> Stable<'tcx> for rustc_session::cstore::ForeignModule { type T = stable_mir::ty::ForeignModule; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { stable_mir::ty::ForeignModule { def_id: tables.foreign_module_def(self.def_id), - abi: self.abi.stable(tables), + abi: self.abi.stable(tables, cx), } } } @@ -898,7 +1062,11 @@ impl<'tcx> Stable<'tcx> for rustc_session::cstore::ForeignModule { impl<'tcx> Stable<'tcx> for ty::AssocKind { type T = stable_mir::ty::AssocKind; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::{AssocKind, AssocTypeData}; match *self { ty::AssocKind::Const { name } => AssocKind::Const { name: name.to_string() }, @@ -909,7 +1077,7 @@ impl<'tcx> Stable<'tcx> for ty::AssocKind { data: match data { ty::AssocTypeData::Normal(name) => AssocTypeData::Normal(name.to_string()), ty::AssocTypeData::Rpitit(rpitit) => { - AssocTypeData::Rpitit(rpitit.stable(tables)) + AssocTypeData::Rpitit(rpitit.stable(tables, cx)) } }, }, @@ -920,7 +1088,7 @@ impl<'tcx> Stable<'tcx> for ty::AssocKind { impl<'tcx> Stable<'tcx> for ty::AssocItemContainer { type T = stable_mir::ty::AssocItemContainer; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { use stable_mir::ty::AssocItemContainer; match self { ty::AssocItemContainer::Trait => AssocItemContainer::Trait, @@ -932,11 +1100,15 @@ impl<'tcx> Stable<'tcx> for ty::AssocItemContainer { impl<'tcx> Stable<'tcx> for ty::AssocItem { type T = stable_mir::ty::AssocItem; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + cx: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { stable_mir::ty::AssocItem { def_id: tables.assoc_def(self.def_id), - kind: self.kind.stable(tables), - container: self.container.stable(tables), + kind: self.kind.stable(tables, cx), + container: self.container.stable(tables, cx), trait_item_def_id: self.trait_item_def_id.map(|did| tables.assoc_def(did)), } } @@ -945,7 +1117,11 @@ impl<'tcx> Stable<'tcx> for ty::AssocItem { impl<'tcx> Stable<'tcx> for ty::ImplTraitInTraitData { type T = stable_mir::ty::ImplTraitInTraitData; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable( + &self, + tables: &mut Tables<'tcx, BridgeTys>, + _: &SmirCtxt<'tcx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::ImplTraitInTraitData; match self { ty::ImplTraitInTraitData::Trait { fn_def_id, opaque_def_id } => { diff --git a/compiler/rustc_smir/src/stable_mir/mod.rs b/compiler/rustc_smir/src/stable_mir/mod.rs index d3ef5f4001dc4..33213fcbe08e1 100644 --- a/compiler/rustc_smir/src/stable_mir/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/mod.rs @@ -41,6 +41,7 @@ use crate::{rustc_smir, stable_mir}; pub mod abi; mod alloc; +pub(crate) mod convert; #[macro_use] pub mod crate_def; pub mod compiler_interface; From a466edb4546dba9eddcd2e3a172bf4e1402140fd Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 5 May 2025 15:40:42 +0800 Subject: [PATCH 08/22] fix: rewrite some parts of `rustc_smir::builder.rs` --- compiler/rustc_smir/src/rustc_smir/builder.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_smir/builder.rs b/compiler/rustc_smir/src/rustc_smir/builder.rs index 40e6d21c06378..b8a1d240e3f8d 100644 --- a/compiler/rustc_smir/src/rustc_smir/builder.rs +++ b/compiler/rustc_smir/src/rustc_smir/builder.rs @@ -9,8 +9,7 @@ use rustc_middle::mir; use rustc_middle::mir::visit::MutVisitor; use rustc_middle::ty::{self, TyCtxt}; -use crate::rustc_smir::{Stable, Tables}; -use crate::stable_mir; +use crate::rustc_smir::{Bridge, Tables}; /// Builds a monomorphic body for a given instance. pub(crate) struct BodyBuilder<'tcx> { @@ -31,7 +30,7 @@ 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(mut self, tables: &mut Tables<'tcx>) -> stable_mir::mir::Body { + pub(crate) fn build(mut self, tables: &mut Tables<'tcx, B>) -> mir::Body<'tcx> { let body = tables.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 @@ -50,7 +49,8 @@ impl<'tcx> BodyBuilder<'tcx> { // Already monomorphic. body }; - mono_body.stable(tables) + + mono_body } } From 6ee30e115e320e9694971bd63600373d5e426d35 Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 5 May 2025 15:41:14 +0800 Subject: [PATCH 09/22] test: fix the usage of `rustc_internal::internal` --- tests/ui-fulldeps/stable-mir/smir_internal.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/tests/ui-fulldeps/stable-mir/smir_internal.rs b/tests/ui-fulldeps/stable-mir/smir_internal.rs index 0519b9de68050..478a5e3f102d2 100644 --- a/tests/ui-fulldeps/stable-mir/smir_internal.rs +++ b/tests/ui-fulldeps/stable-mir/smir_internal.rs @@ -17,18 +17,17 @@ extern crate rustc_interface; extern crate rustc_middle; extern crate stable_mir; -use rustc_middle::ty::TyCtxt; use rustc_smir::rustc_internal; use std::io::Write; use std::ops::ControlFlow; const CRATE_NAME: &str = "input"; -fn test_translation(tcx: TyCtxt<'_>) -> ControlFlow<()> { +fn test_translation() -> ControlFlow<()> { let main_fn = stable_mir::entry_fn().unwrap(); let body = main_fn.expect_body(); let orig_ty = body.locals()[0].ty; - let rustc_ty = rustc_internal::internal(tcx, &orig_ty); + let rustc_ty = rustc_internal::internal(&orig_ty); assert!(rustc_ty.is_unit()); ControlFlow::Continue(()) } @@ -46,7 +45,7 @@ fn main() { CRATE_NAME.to_string(), path.to_string(), ]; - run_with_tcx!(args, test_translation).unwrap(); + run!(args, test_translation).unwrap(); } fn generate_input(path: &str) -> std::io::Result<()> { From c2ad8b796018871a2b02b212b7adde62f887db8c Mon Sep 17 00:00:00 2001 From: Makai Date: Tue, 6 May 2025 12:32:47 +0800 Subject: [PATCH 10/22] cleanup: delete useless methods in `SmirCtxt` --- .../rustc_smir/src/rustc_smir/context/impls.rs | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_smir/context/impls.rs b/compiler/rustc_smir/src/rustc_smir/context/impls.rs index 3151390886231..82fc2b5f889cf 100644 --- a/compiler/rustc_smir/src/rustc_smir/context/impls.rs +++ b/compiler/rustc_smir/src/rustc_smir/context/impls.rs @@ -143,24 +143,6 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { self.tcx.valtree_to_const_val(key) } - pub fn layout_of( - &self, - key: ty::PseudoCanonicalInput<'tcx, Ty<'tcx>>, - ) -> Result>, &ty::layout::LayoutError<'tcx>> { - self.tcx.layout_of(key) - } - - pub fn as_query_input( - &self, - typing_env: ty::TypingEnv<'tcx>, - value: T, - ) -> ty::PseudoCanonicalInput<'tcx, T> - where - T: ty::TypeVisitable>, - { - typing_env.as_query_input(value) - } - pub fn target_endian(&self) -> Endian { self.tcx.data_layout.endian } From 039a9007bfac2cde9d2ed33d17516663653bf51e Mon Sep 17 00:00:00 2001 From: Makai Date: Tue, 6 May 2025 12:41:34 +0800 Subject: [PATCH 11/22] 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`. --- compiler/rustc_smir/src/rustc_internal/mod.rs | 2 +- compiler/rustc_smir/src/rustc_smir/alloc.rs | 35 ++++---- compiler/rustc_smir/src/rustc_smir/builder.rs | 8 +- .../src/rustc_smir/context/impls.rs | 81 ++++++++++++------- .../rustc_smir/src/rustc_smir/context/mod.rs | 14 ++-- compiler/rustc_smir/src/rustc_smir/mod.rs | 49 +---------- compiler/rustc_smir/src/stable_mir/alloc.rs | 11 +-- .../src/stable_mir/compiler_interface.rs | 20 +++-- 8 files changed, 100 insertions(+), 120 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs index 5947a7a844054..db232a1b83a9c 100644 --- a/compiler/rustc_smir/src/rustc_internal/mod.rs +++ b/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)) } diff --git a/compiler/rustc_smir/src/rustc_smir/alloc.rs b/compiler/rustc_smir/src/rustc_smir/alloc.rs index 34692962de707..6b32b5b07d874 100644 --- a/compiler/rustc_smir/src/rustc_smir/alloc.rs +++ b/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>, &'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 { 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 { - 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 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 } diff --git a/compiler/rustc_smir/src/rustc_smir/builder.rs b/compiler/rustc_smir/src/rustc_smir/builder.rs index b8a1d240e3f8d..2141053d09af0 100644 --- a/compiler/rustc_smir/src/rustc_smir/builder.rs +++ b/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,8 +28,8 @@ 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(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 @@ -39,7 +37,7 @@ impl<'tcx> BodyBuilder<'tcx> { || 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), ); diff --git a/compiler/rustc_smir/src/rustc_smir/context/impls.rs b/compiler/rustc_smir/src/rustc_smir/context/impls.rs index 82fc2b5f889cf..d950112f12944 100644 --- a/compiler/rustc_smir/src/rustc_smir/context/impls.rs +++ b/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 { + 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 { + matches!(self.tcx.def_kind(def_id), DefKind::Static { .. }).then(|| def_id) + } + pub fn target_endian(&self) -> Endian { self.tcx.data_layout.endian } @@ -167,8 +207,8 @@ 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 { @@ -176,13 +216,13 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { } /// Retrieve all functions defined in this crate. - pub fn crate_functions(&self, crate_num: CrateNum, tables: &mut Tables<'_, B>) -> Vec { - filter_def_ids(self.tcx, crate_num, |def_id| tables.filter_fn_def(def_id)) + pub fn crate_functions(&self, crate_num: CrateNum) -> Vec { + 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 { - filter_def_ids(self.tcx, crate_num, |def_id| tables.filter_static_def(def_id)) + pub fn crate_statics(&self, crate_num: CrateNum) -> Vec { + 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> { - tables - .instance_has_body(instance) - .then(|| BodyBuilder::new(self.tcx, instance).build(tables)) + pub fn instance_body(&self, instance: ty::Instance<'tcx>) -> Option> { + 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, B::Error> { - let layout = tables.layout_of(ty)?.layout; + pub fn ty_layout(&self, ty: Ty<'tcx>) -> Result, B::Error> { + let layout = self.layout_of(ty)?.layout; Ok(layout) } diff --git a/compiler/rustc_smir/src/rustc_smir/context/mod.rs b/compiler/rustc_smir/src/rustc_smir/context/mod.rs index 75acede8d3451..b31d92cdfca6b 100644 --- a/compiler/rustc_smir/src/rustc_smir/context/mod.rs +++ b/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, } @@ -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, 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() } diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs index 3da67e15cb0b5..a5990751e4700 100644 --- a/compiler/rustc_smir/src/rustc_smir/mod.rs +++ b/compiler/rustc_smir/src/rustc_smir/mod.rs @@ -12,10 +12,9 @@ use std::fmt::Debug; use context::SmirCtxt; use rustc_data_structures::PointeeSized; -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; @@ -31,7 +30,6 @@ pub struct SmirContainer<'tcx, B: Bridge> { } pub struct Tables<'tcx, B: Bridge> { - tcx: TyCtxt<'tcx>, pub(crate) def_ids: IndexMap, pub(crate) alloc_ids: IndexMap, pub(crate) spans: IndexMap, @@ -42,10 +40,9 @@ pub struct Tables<'tcx, B: Bridge> { pub(crate) layouts: IndexMap, 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(), @@ -70,46 +67,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 { - 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 { - 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 diff --git a/compiler/rustc_smir/src/stable_mir/alloc.rs b/compiler/rustc_smir/src/stable_mir/alloc.rs index 4e6facac705e7..5f85d8d34299d 100644 --- a/compiler/rustc_smir/src/stable_mir/alloc.rs +++ b/compiler/rustc_smir/src/stable_mir/alloc.rs @@ -48,20 +48,17 @@ pub(crate) fn try_new_allocation<'tcx>( tables: &mut Tables<'tcx, BridgeTys>, cx: &SmirCtxt<'tcx, BridgeTys>, ) -> Result { - use rustc_smir::context::SmirTypingEnv; - let layout = cx - .layout_of(cx.fully_monomorphized().as_query_input(ty)) - .map_err(|e| Error::from_internal(e))?; + let layout = alloc::create_ty_and_layout(cx, ty).map_err(|e| Error::from_internal(e))?; match const_value { ConstValue::Scalar(scalar) => { - alloc::try_new_scalar(layout, scalar, tables).map(|alloc| alloc.stable(tables, cx)) + alloc::try_new_scalar(layout, scalar, cx).map(|alloc| alloc.stable(tables, cx)) } ConstValue::ZeroSized => Ok(new_empty_allocation(layout.align.abi)), ConstValue::Slice { data, meta } => { - alloc::try_new_slice(layout, data, meta, tables).map(|alloc| alloc.stable(tables, cx)) + alloc::try_new_slice(layout, data, meta, cx).map(|alloc| alloc.stable(tables, cx)) } ConstValue::Indirect { alloc_id, offset } => { - let alloc = alloc::try_new_indirect(alloc_id, tables); + let alloc = alloc::try_new_indirect(alloc_id, cx); use rustc_smir::context::SmirAllocRange; Ok(allocation_filter(&alloc.0, cx.alloc_range(offset, layout.size), tables, cx)) } diff --git a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs index a041339284fd3..31a40dea60995 100644 --- a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs +++ b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs @@ -432,7 +432,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { let tables_ref = &mut *tables; let cx = &*self.cx.borrow(); let def = item.internal(tables_ref, cx); - cx.has_body(def, tables_ref) + cx.has_body(def) } fn foreign_modules(&self, crate_num: CrateNum) -> Vec { @@ -448,18 +448,16 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn crate_functions(&self, crate_num: CrateNum) -> Vec { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let tables_ref = &mut *tables; - let krate = crate_num.internal(tables_ref, cx); - cx.crate_functions(krate, tables_ref).iter().map(|did| tables.fn_def(*did)).collect() + let krate = crate_num.internal(&mut *tables, cx); + cx.crate_functions(krate).iter().map(|did| tables.fn_def(*did)).collect() } /// Retrieve all static items defined in this crate. fn crate_statics(&self, crate_num: CrateNum) -> Vec { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let tables_ref = &mut *tables; - let krate = crate_num.internal(tables_ref, cx); - cx.crate_statics(krate, tables_ref).iter().map(|did| tables.static_def(*did)).collect() + let krate = crate_num.internal(&mut *tables, cx); + cx.crate_statics(krate).iter().map(|did| tables.static_def(*did)).collect() } fn foreign_module(&self, mod_def: ForeignModuleDef) -> ForeignModule { @@ -908,7 +906,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); let instance = tables.instances[instance]; - cx.instance_body(instance, &mut *tables).map(|body| body.stable(&mut *tables, cx)) + cx.instance_body(instance).map(|body| body.stable(&mut *tables, cx)) } /// Get the instance type with generic instantiations applied and lifetimes erased. @@ -1078,7 +1076,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); let instance = tables.instances[def]; - cx.instance_abi(instance, &mut *tables).map(|fn_abi| fn_abi.stable(&mut *tables, cx)) + cx.instance_abi(instance).map(|fn_abi| fn_abi.stable(&mut *tables, cx)) } /// Get the ABI of a function pointer. @@ -1086,7 +1084,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); let sig = fn_ptr.internal(&mut *tables, cx); - cx.fn_ptr_abi(sig, &mut *tables).map(|fn_abi| fn_abi.stable(&mut *tables, cx)) + cx.fn_ptr_abi(sig).map(|fn_abi| fn_abi.stable(&mut *tables, cx)) } /// Get the layout of a type. @@ -1094,7 +1092,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); let internal_ty = ty.internal(&mut *tables, cx); - cx.ty_layout(internal_ty, &mut *tables).map(|layout| layout.stable(&mut *tables, cx)) + cx.ty_layout(internal_ty).map(|layout| layout.stable(&mut *tables, cx)) } /// Get the layout shape. From 3e1936604f28d2a517f2aa074cf59519066c5d30 Mon Sep 17 00:00:00 2001 From: Makai Date: Sun, 11 May 2025 09:03:51 +0000 Subject: [PATCH 12/22] refactor: unify `Tables` implementation with bridge types define bridge types for `***Def`s. consolidate scattered `Tables` implementations into single inherent impl. --- compiler/rustc_smir/src/rustc_internal/mod.rs | 36 +--- compiler/rustc_smir/src/rustc_smir/bridge.rs | 41 ++++ compiler/rustc_smir/src/rustc_smir/mod.rs | 174 +++++++++++++++-- compiler/rustc_smir/src/stable_mir/alloc.rs | 3 +- .../src/stable_mir/compiler_interface.rs | 181 ++++++------------ .../src/stable_mir/convert/stable/mir.rs | 3 +- compiler/rustc_smir/src/stable_mir/error.rs | 2 +- .../rustc_smir/src/stable_mir/mir/mono.rs | 3 +- 8 files changed, 266 insertions(+), 177 deletions(-) create mode 100644 compiler/rustc_smir/src/rustc_smir/bridge.rs diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs index db232a1b83a9c..7701d7e5bd1a0 100644 --- a/compiler/rustc_smir/src/rustc_internal/mod.rs +++ b/compiler/rustc_smir/src/rustc_internal/mod.rs @@ -10,11 +10,8 @@ use std::ops::Index; use rustc_data_structures::fx; use rustc_data_structures::fx::FxIndexMap; -use rustc_middle::mir::interpret::AllocId; -use rustc_middle::ty; use rustc_middle::ty::TyCtxt; -use rustc_span::Span; -use rustc_span::def_id::{CrateNum, DefId}; +use rustc_span::def_id::CrateNum; use scoped_tls::scoped_thread_local; use stable_mir::Error; use stable_mir::convert::{RustcInternal, Stable}; @@ -58,37 +55,6 @@ where with_container(|tables, cx| item.internal(tables, cx)) } -impl<'tcx, B: Bridge> Index for Tables<'tcx, B> { - type Output = DefId; - - #[inline(always)] - fn index(&self, index: B::DefId) -> &Self::Output { - &self.def_ids[index] - } -} - -impl<'tcx, B: Bridge> Tables<'tcx, B> { - pub fn create_def_id(&mut self, did: DefId) -> B::DefId { - self.def_ids.create_or_fetch(did) - } - - pub fn create_alloc_id(&mut self, aid: AllocId) -> B::AllocId { - self.alloc_ids.create_or_fetch(aid) - } - - pub fn create_span(&mut self, span: Span) -> B::Span { - self.spans.create_or_fetch(span) - } - - pub fn instance_def(&mut self, instance: ty::Instance<'tcx>) -> B::InstanceDef { - self.instances.create_or_fetch(instance) - } - - pub fn layout_id(&mut self, layout: rustc_abi::Layout<'tcx>) -> B::Layout { - self.layouts.create_or_fetch(layout) - } -} - pub fn crate_num(item: &stable_mir::Crate) -> CrateNum { item.id.into() } diff --git a/compiler/rustc_smir/src/rustc_smir/bridge.rs b/compiler/rustc_smir/src/rustc_smir/bridge.rs new file mode 100644 index 0000000000000..671b0d2093781 --- /dev/null +++ b/compiler/rustc_smir/src/rustc_smir/bridge.rs @@ -0,0 +1,41 @@ +use std::fmt::Debug; + +use super::Bridge; + +pub trait SmirError { + fn new(msg: String) -> Self; + fn from_internal(err: T) -> Self; +} + +macro_rules! make_def_trait { + ($name:ident) => { + pub trait $name { + fn new(did: B::DefId) -> Self; + } + }; +} + +make_def_trait!(CrateItem); +make_def_trait!(AdtDef); +make_def_trait!(ForeignModuleDef); +make_def_trait!(ForeignDef); +make_def_trait!(FnDef); +make_def_trait!(ClosureDef); +make_def_trait!(CoroutineDef); +make_def_trait!(CoroutineClosureDef); +make_def_trait!(AliasDef); +make_def_trait!(ParamDef); +make_def_trait!(BrNamedDef); +make_def_trait!(TraitDef); +make_def_trait!(GenericDef); +make_def_trait!(ConstDef); +make_def_trait!(ImplDef); +make_def_trait!(RegionDef); +make_def_trait!(CoroutineWitnessDef); +make_def_trait!(AssocDef); +make_def_trait!(OpaqueDef); +make_def_trait!(StaticDef); + +pub trait Prov { + fn new(aid: B::AllocId) -> Self; +} diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs index a5990751e4700..7f04fc2c28385 100644 --- a/compiler/rustc_smir/src/rustc_smir/mod.rs +++ b/compiler/rustc_smir/src/rustc_smir/mod.rs @@ -9,17 +9,21 @@ use std::cell::RefCell; use std::fmt::Debug; +use std::ops::Index; +use bridge::*; use context::SmirCtxt; use rustc_data_structures::PointeeSized; use rustc_middle::mir; use rustc_middle::mir::interpret::AllocId; use rustc_middle::ty::{self, Ty, TyCtxt}; +use rustc_span::Span; use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE}; use crate::rustc_internal::IndexMap; pub mod alloc; +pub mod bridge; mod builder; pub mod context; @@ -30,14 +34,14 @@ pub struct SmirContainer<'tcx, B: Bridge> { } pub struct Tables<'tcx, B: Bridge> { - pub(crate) def_ids: IndexMap, - pub(crate) alloc_ids: IndexMap, - pub(crate) spans: IndexMap, - pub(crate) types: IndexMap, B::Ty>, - pub(crate) instances: IndexMap, B::InstanceDef>, - pub(crate) ty_consts: IndexMap, B::TyConstId>, - pub(crate) mir_consts: IndexMap, B::MirConstId>, - pub(crate) layouts: IndexMap, B::Layout>, + pub def_ids: IndexMap, + pub alloc_ids: IndexMap, + pub spans: IndexMap, + pub types: IndexMap, B::Ty>, + pub instances: IndexMap, B::InstanceDef>, + pub ty_consts: IndexMap, B::TyConstId>, + pub mir_consts: IndexMap, B::MirConstId>, + pub layouts: IndexMap, B::Layout>, } impl<'tcx, B: Bridge> Default for Tables<'tcx, B> { @@ -55,23 +59,142 @@ impl<'tcx, B: Bridge> Default for Tables<'tcx, B> { } } +impl<'tcx, B: Bridge> Index for Tables<'tcx, B> { + type Output = DefId; + + #[inline(always)] + fn index(&self, index: B::DefId) -> &Self::Output { + &self.def_ids[index] + } +} + impl<'tcx, B: Bridge> Tables<'tcx, B> { - pub(crate) fn intern_ty(&mut self, ty: Ty<'tcx>) -> B::Ty { + pub fn intern_ty(&mut self, ty: Ty<'tcx>) -> B::Ty { self.types.create_or_fetch(ty) } - pub(crate) fn intern_ty_const(&mut self, ct: ty::Const<'tcx>) -> B::TyConstId { + pub fn intern_ty_const(&mut self, ct: ty::Const<'tcx>) -> B::TyConstId { self.ty_consts.create_or_fetch(ct) } - pub(crate) fn intern_mir_const(&mut self, constant: mir::Const<'tcx>) -> B::MirConstId { + pub fn intern_mir_const(&mut self, constant: mir::Const<'tcx>) -> B::MirConstId { self.mir_consts.create_or_fetch(constant) } + + pub fn create_def_id(&mut self, did: DefId) -> B::DefId { + self.def_ids.create_or_fetch(did) + } + + pub fn create_alloc_id(&mut self, aid: AllocId) -> B::AllocId { + self.alloc_ids.create_or_fetch(aid) + } + + pub fn create_span(&mut self, span: Span) -> B::Span { + self.spans.create_or_fetch(span) + } + + pub fn instance_def(&mut self, instance: ty::Instance<'tcx>) -> B::InstanceDef { + self.instances.create_or_fetch(instance) + } + + pub fn layout_id(&mut self, layout: rustc_abi::Layout<'tcx>) -> B::Layout { + self.layouts.create_or_fetch(layout) + } + + pub fn crate_item(&mut self, did: rustc_span::def_id::DefId) -> B::CrateItem { + B::CrateItem::new(self.create_def_id(did)) + } + + pub fn adt_def(&mut self, did: rustc_span::def_id::DefId) -> B::AdtDef { + B::AdtDef::new(self.create_def_id(did)) + } + + pub fn foreign_module_def(&mut self, did: rustc_span::def_id::DefId) -> B::ForeignModuleDef { + B::ForeignModuleDef::new(self.create_def_id(did)) + } + + pub fn foreign_def(&mut self, did: rustc_span::def_id::DefId) -> B::ForeignDef { + B::ForeignDef::new(self.create_def_id(did)) + } + + pub fn fn_def(&mut self, did: rustc_span::def_id::DefId) -> B::FnDef { + B::FnDef::new(self.create_def_id(did)) + } + + pub fn closure_def(&mut self, did: rustc_span::def_id::DefId) -> B::ClosureDef { + B::ClosureDef::new(self.create_def_id(did)) + } + + pub fn coroutine_def(&mut self, did: rustc_span::def_id::DefId) -> B::CoroutineDef { + B::CoroutineDef::new(self.create_def_id(did)) + } + + pub fn coroutine_closure_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> B::CoroutineClosureDef { + B::CoroutineClosureDef::new(self.create_def_id(did)) + } + + pub fn alias_def(&mut self, did: rustc_span::def_id::DefId) -> B::AliasDef { + B::AliasDef::new(self.create_def_id(did)) + } + + pub fn param_def(&mut self, did: rustc_span::def_id::DefId) -> B::ParamDef { + B::ParamDef::new(self.create_def_id(did)) + } + + pub fn br_named_def(&mut self, did: rustc_span::def_id::DefId) -> B::BrNamedDef { + B::BrNamedDef::new(self.create_def_id(did)) + } + + pub fn trait_def(&mut self, did: rustc_span::def_id::DefId) -> B::TraitDef { + B::TraitDef::new(self.create_def_id(did)) + } + + pub fn generic_def(&mut self, did: rustc_span::def_id::DefId) -> B::GenericDef { + B::GenericDef::new(self.create_def_id(did)) + } + + pub fn const_def(&mut self, did: rustc_span::def_id::DefId) -> B::ConstDef { + B::ConstDef::new(self.create_def_id(did)) + } + + pub fn impl_def(&mut self, did: rustc_span::def_id::DefId) -> B::ImplDef { + B::ImplDef::new(self.create_def_id(did)) + } + + pub fn region_def(&mut self, did: rustc_span::def_id::DefId) -> B::RegionDef { + B::RegionDef::new(self.create_def_id(did)) + } + + pub fn coroutine_witness_def( + &mut self, + did: rustc_span::def_id::DefId, + ) -> B::CoroutineWitnessDef { + B::CoroutineWitnessDef::new(self.create_def_id(did)) + } + + pub fn assoc_def(&mut self, did: rustc_span::def_id::DefId) -> B::AssocDef { + B::AssocDef::new(self.create_def_id(did)) + } + + pub fn opaque_def(&mut self, did: rustc_span::def_id::DefId) -> B::OpaqueDef { + B::OpaqueDef::new(self.create_def_id(did)) + } + + pub fn prov(&mut self, aid: rustc_middle::mir::interpret::AllocId) -> B::Prov { + B::Prov::new(self.create_alloc_id(aid)) + } + + pub fn static_def(&mut self, did: rustc_span::def_id::DefId) -> B::StaticDef { + B::StaticDef::new(self.create_def_id(did)) + } } /// A trait defining types that are used to emulate StableMIR components, which is really /// useful when programming in stable_mir-agnostic settings. -pub trait Bridge { +pub trait Bridge: Sized { type DefId: Copy + Debug + PartialEq + IndexedVal; type AllocId: Copy + Debug + PartialEq + IndexedVal; type Span: Copy + Debug + PartialEq + IndexedVal; @@ -80,12 +203,29 @@ pub trait Bridge { type TyConstId: Copy + Debug + PartialEq + IndexedVal; type MirConstId: Copy + Debug + PartialEq + IndexedVal; type Layout: Copy + Debug + PartialEq + IndexedVal; - type Error: SmirError; -} -pub trait SmirError { - fn new(msg: String) -> Self; - fn from_internal(err: T) -> Self; + type Error: SmirError; + type CrateItem: CrateItem; + type AdtDef: AdtDef; + type ForeignModuleDef: ForeignModuleDef; + type ForeignDef: ForeignDef; + type FnDef: FnDef; + type ClosureDef: ClosureDef; + type CoroutineDef: CoroutineDef; + type CoroutineClosureDef: CoroutineClosureDef; + type AliasDef: AliasDef; + type ParamDef: ParamDef; + type BrNamedDef: BrNamedDef; + type TraitDef: TraitDef; + type GenericDef: GenericDef; + type ConstDef: ConstDef; + type ImplDef: ImplDef; + type RegionDef: RegionDef; + type CoroutineWitnessDef: CoroutineWitnessDef; + type AssocDef: AssocDef; + type OpaqueDef: OpaqueDef; + type Prov: Prov; + type StaticDef: StaticDef; } pub trait IndexedVal { diff --git a/compiler/rustc_smir/src/stable_mir/alloc.rs b/compiler/rustc_smir/src/stable_mir/alloc.rs index 5f85d8d34299d..43c1ca49e19d0 100644 --- a/compiler/rustc_smir/src/stable_mir/alloc.rs +++ b/compiler/rustc_smir/src/stable_mir/alloc.rs @@ -7,8 +7,9 @@ use rustc_abi::Align; use rustc_middle::mir::ConstValue; use rustc_middle::mir::interpret::AllocRange; +use rustc_smir::bridge::SmirError; use rustc_smir::context::SmirCtxt; -use rustc_smir::{SmirError, Tables, alloc}; +use rustc_smir::{Tables, alloc}; use super::Error; use super::compiler_interface::BridgeTys; diff --git a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs index 31a40dea60995..d932f4f194879 100644 --- a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs +++ b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs @@ -6,7 +6,7 @@ use std::cell::Cell; use rustc_hir::def::DefKind; -use rustc_smir::{Bridge, SmirContainer, Tables}; +use rustc_smir::{Bridge, SmirContainer}; use stable_mir::abi::{FnAbi, Layout, LayoutShape, ReprOptions}; use stable_mir::convert::{RustcInternal, Stable}; use stable_mir::crate_def::Attribute; @@ -39,130 +39,65 @@ impl Bridge for BridgeTys { type TyConstId = stable_mir::ty::TyConstId; type MirConstId = stable_mir::ty::MirConstId; type Layout = stable_mir::abi::Layout; + type Error = stable_mir::Error; + type CrateItem = stable_mir::CrateItem; + type AdtDef = stable_mir::ty::AdtDef; + type ForeignModuleDef = stable_mir::ty::ForeignModuleDef; + type ForeignDef = stable_mir::ty::ForeignDef; + type FnDef = stable_mir::ty::FnDef; + type ClosureDef = stable_mir::ty::ClosureDef; + type CoroutineDef = stable_mir::ty::CoroutineDef; + type CoroutineClosureDef = stable_mir::ty::CoroutineClosureDef; + type AliasDef = stable_mir::ty::AliasDef; + type ParamDef = stable_mir::ty::ParamDef; + type BrNamedDef = stable_mir::ty::BrNamedDef; + type TraitDef = stable_mir::ty::TraitDef; + type GenericDef = stable_mir::ty::GenericDef; + type ConstDef = stable_mir::ty::ConstDef; + type ImplDef = stable_mir::ty::ImplDef; + type RegionDef = stable_mir::ty::RegionDef; + type CoroutineWitnessDef = stable_mir::ty::CoroutineWitnessDef; + type AssocDef = stable_mir::ty::AssocDef; + type OpaqueDef = stable_mir::ty::OpaqueDef; + type Prov = stable_mir::ty::Prov; + type StaticDef = stable_mir::mir::mono::StaticDef; } -impl<'tcx> Tables<'tcx, BridgeTys> { - pub(crate) fn crate_item(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::CrateItem { - stable_mir::CrateItem(self.create_def_id(did)) - } - - pub(crate) fn adt_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::AdtDef { - stable_mir::ty::AdtDef(self.create_def_id(did)) - } - - pub(crate) fn foreign_module_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::ty::ForeignModuleDef { - stable_mir::ty::ForeignModuleDef(self.create_def_id(did)) - } - - pub(crate) fn foreign_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::ty::ForeignDef { - stable_mir::ty::ForeignDef(self.create_def_id(did)) - } - - pub(crate) fn fn_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::FnDef { - stable_mir::ty::FnDef(self.create_def_id(did)) - } - - pub(crate) fn closure_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::ty::ClosureDef { - stable_mir::ty::ClosureDef(self.create_def_id(did)) - } - - pub(crate) fn coroutine_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::ty::CoroutineDef { - stable_mir::ty::CoroutineDef(self.create_def_id(did)) - } - - pub(crate) fn coroutine_closure_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::ty::CoroutineClosureDef { - stable_mir::ty::CoroutineClosureDef(self.create_def_id(did)) - } - - pub(crate) fn alias_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::AliasDef { - stable_mir::ty::AliasDef(self.create_def_id(did)) - } - - pub(crate) fn param_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::ParamDef { - stable_mir::ty::ParamDef(self.create_def_id(did)) - } - - pub(crate) fn br_named_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::ty::BrNamedDef { - stable_mir::ty::BrNamedDef(self.create_def_id(did)) - } - - pub(crate) fn trait_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::TraitDef { - stable_mir::ty::TraitDef(self.create_def_id(did)) - } - - pub(crate) fn generic_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::ty::GenericDef { - stable_mir::ty::GenericDef(self.create_def_id(did)) - } - - pub(crate) fn const_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::ConstDef { - stable_mir::ty::ConstDef(self.create_def_id(did)) - } - - pub(crate) fn impl_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::ImplDef { - stable_mir::ty::ImplDef(self.create_def_id(did)) - } - - /* - pub(crate) fn region_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::ty::RegionDef { - stable_mir::ty::RegionDef(self.create_def_id(did)) +macro_rules! bridge_def { + ($name: ident, $ty: ty) => { + impl rustc_smir::bridge::$name for $ty { + fn new(def: stable_mir::DefId) -> Self { + Self(def) + } } - */ - - pub(crate) fn coroutine_witness_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::ty::CoroutineWitnessDef { - stable_mir::ty::CoroutineWitnessDef(self.create_def_id(did)) - } - - pub(crate) fn assoc_def(&mut self, did: rustc_span::def_id::DefId) -> stable_mir::ty::AssocDef { - stable_mir::ty::AssocDef(self.create_def_id(did)) - } - - pub(crate) fn opaque_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::ty::OpaqueDef { - stable_mir::ty::OpaqueDef(self.create_def_id(did)) - } - - pub(crate) fn prov( - &mut self, - aid: rustc_middle::mir::interpret::AllocId, - ) -> stable_mir::ty::Prov { - stable_mir::ty::Prov(self.create_alloc_id(aid)) - } + }; +} - pub(crate) fn static_def( - &mut self, - did: rustc_span::def_id::DefId, - ) -> stable_mir::mir::mono::StaticDef { - stable_mir::mir::mono::StaticDef(self.create_def_id(did)) +bridge_def!(CrateItem, stable_mir::CrateItem); +bridge_def!(AdtDef, stable_mir::ty::AdtDef); +bridge_def!(ForeignModuleDef, stable_mir::ty::ForeignModuleDef); +bridge_def!(ForeignDef, stable_mir::ty::ForeignDef); +bridge_def!(FnDef, stable_mir::ty::FnDef); +bridge_def!(ClosureDef, stable_mir::ty::ClosureDef); +bridge_def!(CoroutineDef, stable_mir::ty::CoroutineDef); +bridge_def!(CoroutineClosureDef, stable_mir::ty::CoroutineClosureDef); +bridge_def!(AliasDef, stable_mir::ty::AliasDef); +bridge_def!(ParamDef, stable_mir::ty::ParamDef); +bridge_def!(BrNamedDef, stable_mir::ty::BrNamedDef); +bridge_def!(TraitDef, stable_mir::ty::TraitDef); +bridge_def!(GenericDef, stable_mir::ty::GenericDef); +bridge_def!(ConstDef, stable_mir::ty::ConstDef); +bridge_def!(ImplDef, stable_mir::ty::ImplDef); +bridge_def!(RegionDef, stable_mir::ty::RegionDef); +bridge_def!(CoroutineWitnessDef, stable_mir::ty::CoroutineWitnessDef); +bridge_def!(AssocDef, stable_mir::ty::AssocDef); +bridge_def!(OpaqueDef, stable_mir::ty::OpaqueDef); +bridge_def!(StaticDef, stable_mir::mir::mono::StaticDef); + +impl rustc_smir::bridge::Prov for stable_mir::ty::Prov { + fn new(aid: stable_mir::mir::alloc::AllocId) -> Self { + Self(aid) } } @@ -1138,7 +1073,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { } } -impl<'tcx> SmirContainer<'tcx, BridgeTys> { +impl<'tcx> Helper for SmirContainer<'tcx, BridgeTys> { fn smir_crate(&self, crate_num: rustc_span::def_id::CrateNum) -> Crate { let cx = &*self.cx.borrow(); let name = cx.crate_name(crate_num); @@ -1149,6 +1084,10 @@ impl<'tcx> SmirContainer<'tcx, BridgeTys> { } } +trait Helper { + fn smir_crate(&self, crate_num: rustc_span::def_id::CrateNum) -> Crate; +} + // A thread local variable that stores a pointer to [`SmirInterface`]. scoped_tls::scoped_thread_local!(static TLV: Cell<*const ()>); diff --git a/compiler/rustc_smir/src/stable_mir/convert/stable/mir.rs b/compiler/rustc_smir/src/stable_mir/convert/stable/mir.rs index 34c6663c63cae..98b828248354a 100644 --- a/compiler/rustc_smir/src/stable_mir/convert/stable/mir.rs +++ b/compiler/rustc_smir/src/stable_mir/convert/stable/mir.rs @@ -2,8 +2,9 @@ use rustc_middle::mir::mono::MonoItem; use rustc_middle::{bug, mir}; +use rustc_smir::Tables; +use rustc_smir::bridge::SmirError; use rustc_smir::context::SmirCtxt; -use rustc_smir::{SmirError, Tables}; use stable_mir::compiler_interface::BridgeTys; use stable_mir::convert::Stable; use stable_mir::mir::alloc::GlobalAlloc; diff --git a/compiler/rustc_smir/src/stable_mir/error.rs b/compiler/rustc_smir/src/stable_mir/error.rs index c6bf96ebd1763..3f9d67954b9d3 100644 --- a/compiler/rustc_smir/src/stable_mir/error.rs +++ b/compiler/rustc_smir/src/stable_mir/error.rs @@ -7,7 +7,7 @@ use std::fmt::{Debug, Display, Formatter}; use std::{fmt, io}; -use rustc_smir::SmirError; +use rustc_smir::bridge::SmirError; use crate::rustc_smir; diff --git a/compiler/rustc_smir/src/stable_mir/mir/mono.rs b/compiler/rustc_smir/src/stable_mir/mir/mono.rs index 4d16b3bef5194..e84852bf5267a 100644 --- a/compiler/rustc_smir/src/stable_mir/mir/mono.rs +++ b/compiler/rustc_smir/src/stable_mir/mir/mono.rs @@ -1,7 +1,8 @@ use std::fmt::{Debug, Formatter}; use std::io; -use rustc_smir::{IndexedVal, SmirError}; +use rustc_smir::IndexedVal; +use rustc_smir::bridge::SmirError; use serde::Serialize; use stable_mir::abi::FnAbi; use stable_mir::crate_def::CrateDef; From ddc0025549558641c542f92d6a40c71aee721921 Mon Sep 17 00:00:00 2001 From: Makai Date: Sun, 11 May 2025 09:29:44 +0000 Subject: [PATCH 13/22] refactor: move `IndexMap` to `rustc_smir` we should no longer keep `IndexMap` in `rustc_internal`, as we've decided to migrate `rustc_internal` to `stable_mir` under a feature. --- compiler/rustc_smir/src/rustc_internal/mod.rs | 39 +------------------ compiler/rustc_smir/src/rustc_smir/mod.rs | 36 ++++++++++++++++- 2 files changed, 35 insertions(+), 40 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs index 7701d7e5bd1a0..b99514a3b7309 100644 --- a/compiler/rustc_smir/src/rustc_internal/mod.rs +++ b/compiler/rustc_smir/src/rustc_internal/mod.rs @@ -4,12 +4,7 @@ //! until stable MIR is complete. use std::cell::{Cell, RefCell}; -use std::fmt::Debug; -use std::hash::Hash; -use std::ops::Index; -use rustc_data_structures::fx; -use rustc_data_structures::fx::FxIndexMap; use rustc_middle::ty::TyCtxt; use rustc_span::def_id::CrateNum; use scoped_tls::scoped_thread_local; @@ -17,7 +12,7 @@ use stable_mir::Error; use stable_mir::convert::{RustcInternal, Stable}; use crate::rustc_smir::context::SmirCtxt; -use crate::rustc_smir::{Bridge, IndexedVal, SmirContainer, Tables}; +use crate::rustc_smir::{Bridge, SmirContainer, Tables}; use crate::stable_mir; pub mod pretty; @@ -273,35 +268,3 @@ macro_rules! run_driver { StableMir::new($callback).run($args) }}; } - -/// Similar to rustc's `FxIndexMap`, `IndexMap` with extra -/// safety features added. -pub struct IndexMap { - index_map: fx::FxIndexMap, -} - -impl Default for IndexMap { - fn default() -> Self { - Self { index_map: FxIndexMap::default() } - } -} - -impl IndexMap { - pub fn create_or_fetch(&mut self, key: K) -> V { - let len = self.index_map.len(); - let v = self.index_map.entry(key).or_insert(V::to_val(len)); - *v - } -} - -impl Index - for IndexMap -{ - type Output = K; - - fn index(&self, index: V) -> &Self::Output { - let (k, v) = self.index_map.get_index(index.to_index()).unwrap(); - assert_eq!(*v, index, "Provided value doesn't match with indexed value"); - k - } -} diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs index 7f04fc2c28385..3e40a4a80dbcc 100644 --- a/compiler/rustc_smir/src/rustc_smir/mod.rs +++ b/compiler/rustc_smir/src/rustc_smir/mod.rs @@ -9,10 +9,12 @@ use std::cell::RefCell; use std::fmt::Debug; +use std::hash::Hash; use std::ops::Index; use bridge::*; use context::SmirCtxt; +use rustc_data_structures::fx::{self, FxIndexMap}; use rustc_data_structures::PointeeSized; use rustc_middle::mir; use rustc_middle::mir::interpret::AllocId; @@ -20,8 +22,6 @@ use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::Span; use rustc_span::def_id::{CrateNum, DefId, LOCAL_CRATE}; -use crate::rustc_internal::IndexMap; - pub mod alloc; pub mod bridge; mod builder; @@ -234,6 +234,38 @@ pub trait IndexedVal { fn to_index(&self) -> usize; } +/// Similar to rustc's `FxIndexMap`, `IndexMap` with extra +/// safety features added. +pub struct IndexMap { + index_map: fx::FxIndexMap, +} + +impl Default for IndexMap { + fn default() -> Self { + Self { index_map: FxIndexMap::default() } + } +} + +impl IndexMap { + pub fn create_or_fetch(&mut self, key: K) -> V { + let len = self.index_map.len(); + let v = self.index_map.entry(key).or_insert(V::to_val(len)); + *v + } +} + +impl Index + for IndexMap +{ + type Output = K; + + fn index(&self, index: V) -> &Self::Output { + let (k, v) = self.index_map.get_index(index.to_index()).unwrap(); + assert_eq!(*v, index, "Provided value doesn't match with indexed value"); + k + } +} + /// Iterate over the definitions of the given crate. pub(crate) fn filter_def_ids(tcx: TyCtxt<'_>, krate: CrateNum, mut func: F) -> Vec where From 2b84a2e701236b85e48a36e92c62489947704873 Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 9 Jun 2025 08:13:27 +0000 Subject: [PATCH 14/22] 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`. --- compiler/rustc_smir/src/rustc_internal/mod.rs | 13 +- compiler/rustc_smir/src/rustc_smir/alloc.rs | 4 +- .../src/rustc_smir/context/impls.rs | 77 +----- .../rustc_smir/src/rustc_smir/context/mod.rs | 4 +- .../src/rustc_smir/context/traits.rs | 4 - .../src/stable_mir/compiler_interface.rs | 145 +++++----- .../{ => unstable}/convert/internal.rs | 253 +++++++++--------- .../rustc_smir/src/stable_mir/unstable/mod.rs | 208 ++++++++++++++ 8 files changed, 420 insertions(+), 288 deletions(-) rename compiler/rustc_smir/src/stable_mir/{ => unstable}/convert/internal.rs (78%) create mode 100644 compiler/rustc_smir/src/stable_mir/unstable/mod.rs diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs index b99514a3b7309..a8d2ab55d037b 100644 --- a/compiler/rustc_smir/src/rustc_internal/mod.rs +++ b/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( + 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) diff --git a/compiler/rustc_smir/src/rustc_smir/alloc.rs b/compiler/rustc_smir/src/rustc_smir/alloc.rs index 6b32b5b07d874..f5412806d3358 100644 --- a/compiler/rustc_smir/src/rustc_smir/alloc.rs +++ b/compiler/rustc_smir/src/rustc_smir/alloc.rs @@ -43,8 +43,8 @@ pub fn try_new_slice<'tcx, B: Bridge>( ) -> Result { 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) diff --git a/compiler/rustc_smir/src/rustc_smir/context/impls.rs b/compiler/rustc_smir/src/rustc_smir/context/impls.rs index d950112f12944..4ca785d1e9635 100644 --- a/compiler/rustc_smir/src/rustc_smir/context/impls.rs +++ b/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>>(&self, value: T) -> Option { self.tcx.lift(value) } - pub fn mk_args_from_iter(&self, iter: I) -> T::Output - where - I: Iterator, - T: ty::CollectAndApply, 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> { - self.tcx.mk_poly_existential_predicates(eps) - } - - pub fn mk_type_list(&self, v: &[Ty<'tcx>]) -> &'tcx List> { - self.tcx.mk_type_list(v) - } - - pub fn mk_bound_variable_kinds_from_iter(&self, iter: I) -> T::Output - where - I: Iterator, - T: ty::CollectAndApply>, - { - self.tcx.mk_bound_variable_kinds_from_iter(iter) - } - - pub fn mk_place_elems(&self, v: &[mir::PlaceElem<'tcx>]) -> &'tcx List> { - self.tcx.mk_place_elems(v) - } - pub fn adt_def(&self, def_id: DefId) -> AdtDef<'tcx> { self.tcx.adt_def(def_id) } diff --git a/compiler/rustc_smir/src/rustc_smir/context/mod.rs b/compiler/rustc_smir/src/rustc_smir/context/mod.rs index b31d92cdfca6b..38743e5f7d372 100644 --- a/compiler/rustc_smir/src/rustc_smir/context/mod.rs +++ b/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, } 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() } } } diff --git a/compiler/rustc_smir/src/rustc_smir/context/traits.rs b/compiler/rustc_smir/src/rustc_smir/context/traits.rs index f5cd7c330b8fe..19e09016cddef 100644 --- a/compiler/rustc_smir/src/rustc_smir/context/traits.rs +++ b/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>; -} diff --git a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs index d932f4f194879..88b2f13173a9b 100644 --- a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs +++ b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs @@ -6,6 +6,7 @@ use std::cell::Cell; use rustc_hir::def::DefKind; +use rustc_smir::context::SmirCtxt; use rustc_smir::{Bridge, SmirContainer}; use stable_mir::abi::{FnAbi, Layout, LayoutShape, ReprOptions}; use stable_mir::convert::{RustcInternal, Stable}; @@ -364,16 +365,15 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { /// Check whether the body of a function is available. fn has_body(&self, item: DefId) -> bool { let mut tables = self.tables.borrow_mut(); - let tables_ref = &mut *tables; let cx = &*self.cx.borrow(); - let def = item.internal(tables_ref, cx); + let def = item.internal(&mut *tables, cx.tcx); cx.has_body(def) } fn foreign_modules(&self, crate_num: CrateNum) -> Vec { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - cx.foreign_modules(crate_num.internal(&mut *tables, cx)) + cx.foreign_modules(crate_num.internal(&mut *tables, cx.tcx)) .iter() .map(|did| tables.foreign_module_def(*did)) .collect() @@ -383,7 +383,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn crate_functions(&self, crate_num: CrateNum) -> Vec { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let krate = crate_num.internal(&mut *tables, cx); + let krate = crate_num.internal(&mut *tables, cx.tcx); cx.crate_functions(krate).iter().map(|did| tables.fn_def(*did)).collect() } @@ -391,7 +391,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn crate_statics(&self, crate_num: CrateNum) -> Vec { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let krate = crate_num.internal(&mut *tables, cx); + let krate = crate_num.internal(&mut *tables, cx.tcx); cx.crate_statics(krate).iter().map(|did| tables.static_def(*did)).collect() } @@ -418,7 +418,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn trait_decls(&self, crate_num: CrateNum) -> TraitDecls { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let krate = crate_num.internal(&mut *tables, cx); + let krate = crate_num.internal(&mut *tables, cx.tcx); cx.trait_decls(krate).iter().map(|did| tables.trait_def(*did)).collect() } @@ -438,7 +438,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn trait_impls(&self, crate_num: CrateNum) -> ImplTraitDecls { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let krate = crate_num.internal(&mut *tables, cx); + let krate = crate_num.internal(&mut *tables, cx.tcx); cx.trait_impls(krate).iter().map(|did| tables.impl_def(*did)).collect() } @@ -498,19 +498,19 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { /// Get information about the local crate. fn local_crate(&self) -> Crate { let cx = &*self.cx.borrow(); - self.smir_crate(cx.local_crate_num()) + smir_crate(cx, cx.local_crate_num()) } /// Retrieve a list of all external crates. fn external_crates(&self) -> Vec { let cx = &*self.cx.borrow(); - cx.external_crates().iter().map(|crate_num| self.smir_crate(*crate_num)).collect() + cx.external_crates().iter().map(|crate_num| smir_crate(cx, *crate_num)).collect() } /// Find a crate with the given name. fn find_crates(&self, name: &str) -> Vec { let cx = &*self.cx.borrow(); - cx.find_crates(name).iter().map(|crate_num| self.smir_crate(*crate_num)).collect() + cx.find_crates(name).iter().map(|crate_num| smir_crate(cx, *crate_num)).collect() } /// Returns the name of given `DefId`. @@ -611,28 +611,28 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn adt_kind(&self, def: AdtDef) -> AdtKind { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - cx.adt_kind(def.internal(&mut *tables, cx)).stable(&mut *tables, cx) + cx.adt_kind(def.internal(&mut *tables, cx.tcx)).stable(&mut *tables, cx) } /// Returns if the ADT is a box. fn adt_is_box(&self, def: AdtDef) -> bool { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - cx.adt_is_box(def.internal(&mut *tables, cx)) + cx.adt_is_box(def.internal(&mut *tables, cx.tcx)) } /// Returns whether this ADT is simd. fn adt_is_simd(&self, def: AdtDef) -> bool { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - cx.adt_is_simd(def.internal(&mut *tables, cx)) + cx.adt_is_simd(def.internal(&mut *tables, cx.tcx)) } /// Returns whether this definition is a C string. fn adt_is_cstr(&self, def: AdtDef) -> bool { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - cx.adt_is_cstr(def.0.internal(&mut *tables, cx)) + cx.adt_is_cstr(def.0.internal(&mut *tables, cx.tcx)) } /// Returns the representation options for this ADT @@ -644,8 +644,8 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let def_id = def.0.internal(&mut *tables, cx); - let args_ref = args.internal(&mut *tables, cx); + let def_id = def.0.internal(&mut *tables, cx.tcx); + let args_ref = args.internal(&mut *tables, cx.tcx); cx.fn_sig(def_id, args_ref).stable(&mut *tables, cx) } @@ -653,7 +653,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn intrinsic(&self, item: DefId) -> Option { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let def_id = item.internal(&mut *tables, cx); + let def_id = item.internal(&mut *tables, cx.tcx); cx.intrinsic(def_id).map(|_| IntrinsicDef(item)) } @@ -661,7 +661,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let def_id = def.0.internal(&mut *tables, cx); + let def_id = def.0.internal(&mut *tables, cx.tcx); cx.intrinsic_name(def_id) } @@ -669,7 +669,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let args_ref = args.internal(&mut *tables, cx); + let args_ref = args.internal(&mut *tables, cx.tcx); cx.closure_sig(args_ref).stable(&mut *tables, cx) } @@ -677,7 +677,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn adt_variants_len(&self, def: AdtDef) -> usize { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - cx.adt_variants_len(def.internal(&mut *tables, cx)) + cx.adt_variants_len(def.internal(&mut *tables, cx.tcx)) } /// Discriminant for a given variant index of AdtDef @@ -699,27 +699,31 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn variant_name(&self, def: VariantDef) -> Symbol { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - cx.variant_name(def.internal(&mut *tables, cx)) + cx.variant_name(def.internal(&mut *tables, cx.tcx)) } fn variant_fields(&self, def: VariantDef) -> Vec { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - def.internal(&mut *tables, cx).fields.iter().map(|f| f.stable(&mut *tables, cx)).collect() + def.internal(&mut *tables, cx.tcx) + .fields + .iter() + .map(|f| f.stable(&mut *tables, cx)) + .collect() } /// Evaluate constant as a target usize. fn eval_target_usize(&self, mir_const: &MirConst) -> Result { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let cnst = mir_const.internal(&mut *tables, cx); + let cnst = mir_const.internal(&mut *tables, cx.tcx); cx.eval_target_usize(cnst) } fn eval_target_usize_ty(&self, ty_const: &TyConst) -> Result { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let cnst = ty_const.internal(&mut *tables, cx); + let cnst = ty_const.internal(&mut *tables, cx.tcx); cx.eval_target_usize_ty(cnst) } @@ -727,7 +731,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn try_new_const_zst(&self, ty: Ty) -> Result { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let ty_internal = ty.internal(&mut *tables, cx); + let ty_internal = ty.internal(&mut *tables, cx.tcx); cx.try_new_const_zst(ty_internal).map(|cnst| cnst.stable(&mut *tables, cx)) } @@ -749,14 +753,14 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn try_new_const_uint(&self, value: u128, uint_ty: UintTy) -> Result { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let ty = cx.ty_new_uint(uint_ty.internal(&mut *tables, cx)); + let ty = cx.ty_new_uint(uint_ty.internal(&mut *tables, cx.tcx)); cx.try_new_const_uint(value, ty).map(|cnst| cnst.stable(&mut *tables, cx)) } fn try_new_ty_const_uint(&self, value: u128, uint_ty: UintTy) -> Result { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let ty = cx.ty_new_uint(uint_ty.internal(&mut *tables, cx)); + let ty = cx.ty_new_uint(uint_ty.internal(&mut *tables, cx.tcx)); cx.try_new_ty_const_uint(value, ty).map(|cnst| cnst.stable(&mut *tables, cx)) } @@ -764,7 +768,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn new_rigid_ty(&self, kind: RigidTy) -> Ty { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let internal_kind = kind.internal(&mut *tables, cx); + let internal_kind = kind.internal(&mut *tables, cx.tcx); cx.new_rigid_ty(internal_kind).stable(&mut *tables, cx) } @@ -772,7 +776,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn new_box_ty(&self, ty: Ty) -> Ty { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let inner = ty.internal(&mut *tables, cx); + let inner = ty.internal(&mut *tables, cx.tcx); cx.new_box_ty(inner).stable(&mut *tables, cx) } @@ -780,7 +784,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn def_ty(&self, item: DefId) -> Ty { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let inner = item.internal(&mut *tables, cx); + let inner = item.internal(&mut *tables, cx.tcx); cx.def_ty(inner).stable(&mut *tables, cx) } @@ -788,8 +792,8 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn def_ty_with_args(&self, item: DefId, args: &GenericArgs) -> Ty { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let inner = item.internal(&mut *tables, cx); - let args_ref = args.internal(&mut *tables, cx); + let inner = item.internal(&mut *tables, cx.tcx); + let args_ref = args.internal(&mut *tables, cx.tcx); cx.def_ty_with_args(inner, args_ref).stable(&mut *tables, cx) } @@ -797,7 +801,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn mir_const_pretty(&self, cnst: &MirConst) -> String { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - cnst.internal(&mut *tables, cx).to_string() + cnst.internal(&mut *tables, cx.tcx).to_string() } /// `Span` of an item. @@ -832,7 +836,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn rigid_ty_discriminant_ty(&self, ty: &RigidTy) -> Ty { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let internal_kind = ty.internal(&mut *tables, cx); + let internal_kind = ty.internal(&mut *tables, cx.tcx); cx.rigid_ty_discriminant_ty(internal_kind).stable(&mut *tables, cx) } @@ -905,8 +909,8 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn resolve_instance(&self, def: FnDef, args: &GenericArgs) -> Option { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let def_id = def.0.internal(&mut *tables, cx); - let args_ref = args.internal(&mut *tables, cx); + let def_id = def.0.internal(&mut *tables, cx.tcx); + let args_ref = args.internal(&mut *tables, cx.tcx); cx.resolve_instance(def_id, args_ref).map(|inst| inst.stable(&mut *tables, cx)) } @@ -914,7 +918,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn resolve_drop_in_place(&self, ty: Ty) -> Instance { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let internal_ty = ty.internal(&mut *tables, cx); + let internal_ty = ty.internal(&mut *tables, cx.tcx); cx.resolve_drop_in_place(internal_ty).stable(&mut *tables, cx) } @@ -923,8 +927,8 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn resolve_for_fn_ptr(&self, def: FnDef, args: &GenericArgs) -> Option { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let def_id = def.0.internal(&mut *tables, cx); - let args_ref = args.internal(&mut *tables, cx); + let def_id = def.0.internal(&mut *tables, cx.tcx); + let args_ref = args.internal(&mut *tables, cx.tcx); cx.resolve_for_fn_ptr(def_id, args_ref).stable(&mut *tables, cx) } @@ -937,9 +941,9 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { ) -> Option { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let def_id = def.0.internal(&mut *tables, cx); - let args_ref = args.internal(&mut *tables, cx); - let closure_kind = kind.internal(&mut *tables, cx); + let def_id = def.0.internal(&mut *tables, cx.tcx); + let args_ref = args.internal(&mut *tables, cx.tcx); + let closure_kind = kind.internal(&mut *tables, cx.tcx); cx.resolve_closure(def_id, args_ref, closure_kind).map(|inst| inst.stable(&mut *tables, cx)) } @@ -947,7 +951,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn eval_static_initializer(&self, def: StaticDef) -> Result { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let def_id = def.0.internal(&mut *tables, cx); + let def_id = def.0.internal(&mut *tables, cx.tcx); cx.eval_static_initializer(def_id).stable(&mut *tables, cx) } @@ -957,7 +961,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { let mut tables = self.tables.borrow_mut(); let instance = tables.instances[def]; let cx = &*self.cx.borrow(); - let const_ty = const_ty.internal(&mut *tables, cx); + let const_ty = const_ty.internal(&mut *tables, cx.tcx); cx.eval_instance(instance) .map(|const_val| alloc::try_new_allocation(const_ty, const_val, &mut *tables, cx)) .map_err(|e| e.stable(&mut *tables, cx))? @@ -967,7 +971,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn global_alloc(&self, id: AllocId) -> GlobalAlloc { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let alloc_id = id.internal(&mut *tables, cx); + let alloc_id = id.internal(&mut *tables, cx.tcx); cx.global_alloc(alloc_id).stable(&mut *tables, cx) } @@ -978,15 +982,16 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { return None; }; let cx = &*self.cx.borrow(); - let ty = ty.internal(&mut *tables, cx); - let trait_ref = trait_ref.internal(&mut *tables, cx); + let ty = ty.internal(&mut *tables, cx.tcx); + let trait_ref = trait_ref.internal(&mut *tables, cx.tcx); let alloc_id = cx.vtable_allocation(ty, trait_ref); Some(alloc_id.stable(&mut *tables, cx)) } fn krate(&self, def_id: DefId) -> Crate { let tables = self.tables.borrow(); - self.smir_crate(tables[def_id].krate) + let cx = &*self.cx.borrow(); + smir_crate(cx, tables[def_id].krate) } fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol { @@ -1018,7 +1023,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn fn_ptr_abi(&self, fn_ptr: PolyFnSig) -> Result { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let sig = fn_ptr.internal(&mut *tables, cx); + let sig = fn_ptr.internal(&mut *tables, cx.tcx); cx.fn_ptr_abi(sig).map(|fn_abi| fn_abi.stable(&mut *tables, cx)) } @@ -1026,7 +1031,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn ty_layout(&self, ty: Ty) -> Result { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let internal_ty = ty.internal(&mut *tables, cx); + let internal_ty = ty.internal(&mut *tables, cx.tcx); cx.ty_layout(internal_ty).map(|layout| layout.stable(&mut *tables, cx)) } @@ -1034,7 +1039,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn layout_shape(&self, id: Layout) -> LayoutShape { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - id.internal(&mut *tables, cx).0.stable(&mut *tables, cx) + id.internal(&mut *tables, cx.tcx).0.stable(&mut *tables, cx) } /// Get a debug string representation of a place. @@ -1042,16 +1047,16 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - format!("{:?}", place.internal(&mut *tables, cx)) + format!("{:?}", place.internal(&mut *tables, cx.tcx)) } /// Get the resulting type of binary operation. fn binop_ty(&self, bin_op: BinOp, rhs: Ty, lhs: Ty) -> Ty { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let rhs_internal = rhs.internal(&mut *tables, cx); - let lhs_internal = lhs.internal(&mut *tables, cx); - let bin_op_internal = bin_op.internal(&mut *tables, cx); + let rhs_internal = rhs.internal(&mut *tables, cx.tcx); + let lhs_internal = lhs.internal(&mut *tables, cx.tcx); + let bin_op_internal = bin_op.internal(&mut *tables, cx.tcx); cx.binop_ty(bin_op_internal, rhs_internal, lhs_internal).stable(&mut *tables, cx) } @@ -1059,8 +1064,8 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { fn unop_ty(&self, un_op: UnOp, arg: Ty) -> Ty { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); - let un_op = un_op.internal(&mut *tables, cx); - let arg = arg.internal(&mut *tables, cx); + let un_op = un_op.internal(&mut *tables, cx.tcx); + let arg = arg.internal(&mut *tables, cx.tcx); cx.unop_ty(un_op, arg).stable(&mut *tables, cx) } @@ -1073,21 +1078,6 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { } } -impl<'tcx> Helper for SmirContainer<'tcx, BridgeTys> { - fn smir_crate(&self, crate_num: rustc_span::def_id::CrateNum) -> Crate { - let cx = &*self.cx.borrow(); - let name = cx.crate_name(crate_num); - let is_local = cx.crate_is_local(crate_num); - let id = cx.crate_num_id(crate_num); - debug!(?name, ?crate_num, "smir_crate"); - Crate { id, name, is_local } - } -} - -trait Helper { - fn smir_crate(&self, crate_num: rustc_span::def_id::CrateNum) -> Crate; -} - // A thread local variable that stores a pointer to [`SmirInterface`]. scoped_tls::scoped_thread_local!(static TLV: Cell<*const ()>); @@ -1115,3 +1105,14 @@ pub(crate) fn with(f: impl FnOnce(&dyn SmirInterface) -> R) -> R { f(unsafe { *(ptr as *const &dyn SmirInterface) }) }) } + +fn smir_crate<'tcx>( + cx: &SmirCtxt<'tcx, BridgeTys>, + crate_num: rustc_span::def_id::CrateNum, +) -> Crate { + let name = cx.crate_name(crate_num); + let is_local = cx.crate_is_local(crate_num); + let id = cx.crate_num_id(crate_num); + debug!(?name, ?crate_num, "smir_crate"); + Crate { id, name, is_local } +} diff --git a/compiler/rustc_smir/src/stable_mir/convert/internal.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs similarity index 78% rename from compiler/rustc_smir/src/stable_mir/convert/internal.rs rename to compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs index 9006e5ca28190..bd7aa6d09d1f0 100644 --- a/compiler/rustc_smir/src/stable_mir/convert/internal.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs @@ -6,12 +6,11 @@ // Prefer importing stable_mir over internal rustc constructs to make this file more readable. use rustc_middle::ty::{self as rustc_ty, Const as InternalConst, Ty as InternalTy}; -use rustc_smir::context::SmirCtxt; -use rustc_smir::{IndexedVal, Tables}; +use rustc_smir::Tables; use rustc_span::Symbol; use stable_mir::abi::Layout; use stable_mir::compiler_interface::BridgeTys; -use stable_mir::convert::RustcInternal; +use stable_mir::unstable::{RustcInternal, InternalCx}; use stable_mir::mir::alloc::AllocId; use stable_mir::mir::mono::{Instance, MonoItem, StaticDef}; use stable_mir::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp}; @@ -21,18 +20,19 @@ use stable_mir::ty::{ GenericArgKind, GenericArgs, IntTy, MirConst, Movability, Pattern, Region, RigidTy, Span, TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx, }; -use stable_mir::{CrateItem, CrateNum, DefId}; +use stable_mir::{CrateItem, CrateNum, DefId, IndexedVal}; use crate::{rustc_smir, stable_mir}; + impl RustcInternal for CrateItem { type T<'tcx> = rustc_span::def_id::DefId; fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - self.0.internal(tables, cx) + self.0.internal(tables, tcx) } } @@ -41,7 +41,7 @@ impl RustcInternal for CrateNum { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { rustc_span::def_id::CrateNum::from_usize(*self) } @@ -52,9 +52,9 @@ impl RustcInternal for DefId { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - cx.lift(tables.def_ids[*self]).unwrap() + tcx.lift(tables.def_ids[*self]).unwrap() } } @@ -63,9 +63,9 @@ impl RustcInternal for GenericArgs { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - cx.mk_args_from_iter(self.0.iter().map(|arg| arg.internal(tables, cx))) + InternalCx::mk_args_from_iter(tcx, self.0.iter().map(|arg| arg.internal(tables, tcx))) } } @@ -74,14 +74,14 @@ impl RustcInternal for GenericArgKind { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { let arg: rustc_ty::GenericArg<'tcx> = match self { - GenericArgKind::Lifetime(reg) => reg.internal(tables, cx).into(), - GenericArgKind::Type(ty) => ty.internal(tables, cx).into(), - GenericArgKind::Const(cnst) => cnst.internal(tables, cx).into(), + GenericArgKind::Lifetime(reg) => reg.internal(tables, tcx).into(), + GenericArgKind::Type(ty) => ty.internal(tables, tcx).into(), + GenericArgKind::Const(cnst) => cnst.internal(tables, tcx).into(), }; - cx.lift(arg).unwrap() + tcx.lift(arg).unwrap() } } @@ -90,11 +90,10 @@ impl RustcInternal for Region { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { // Cannot recover region. Use erased for now. - use rustc_smir::context::SmirRegion; - cx.lifetimes_re_erased() + tcx.lifetimes_re_erased() } } @@ -103,9 +102,9 @@ impl RustcInternal for Ty { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - cx.lift(tables.types[*self]).unwrap() + tcx.lift(tables.types[*self]).unwrap() } } @@ -114,9 +113,9 @@ impl RustcInternal for TyConst { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - cx.lift(tables.ty_consts[self.id]).unwrap() + tcx.lift(tables.ty_consts[self.id]).unwrap() } } @@ -125,12 +124,12 @@ impl RustcInternal for Pattern { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - cx.mk_pat(match self { + tcx.mk_pat(match self { Pattern::Range { start, end, include_end: _ } => rustc_ty::PatternKind::Range { - start: start.as_ref().unwrap().internal(tables, cx), - end: end.as_ref().unwrap().internal(tables, cx), + start: start.as_ref().unwrap().internal(tables, tcx), + end: end.as_ref().unwrap().internal(tables, tcx), }, }) } @@ -142,63 +141,63 @@ impl RustcInternal for RigidTy { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { RigidTy::Bool => rustc_ty::TyKind::Bool, RigidTy::Char => rustc_ty::TyKind::Char, - RigidTy::Int(int_ty) => rustc_ty::TyKind::Int(int_ty.internal(tables, cx)), - RigidTy::Uint(uint_ty) => rustc_ty::TyKind::Uint(uint_ty.internal(tables, cx)), - RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables, cx)), + 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, tcx)), + RigidTy::Float(float_ty) => rustc_ty::TyKind::Float(float_ty.internal(tables, tcx)), RigidTy::Never => rustc_ty::TyKind::Never, RigidTy::Array(ty, cnst) => { - rustc_ty::TyKind::Array(ty.internal(tables, cx), cnst.internal(tables, cx)) + rustc_ty::TyKind::Array(ty.internal(tables, tcx), cnst.internal(tables, tcx)) } RigidTy::Pat(ty, pat) => { - rustc_ty::TyKind::Pat(ty.internal(tables, cx), pat.internal(tables, cx)) + rustc_ty::TyKind::Pat(ty.internal(tables, tcx), pat.internal(tables, tcx)) } RigidTy::Adt(def, args) => { - rustc_ty::TyKind::Adt(def.internal(tables, cx), args.internal(tables, cx)) + rustc_ty::TyKind::Adt(def.internal(tables, tcx), args.internal(tables, tcx)) } RigidTy::Str => rustc_ty::TyKind::Str, - RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, cx)), + RigidTy::Slice(ty) => rustc_ty::TyKind::Slice(ty.internal(tables, tcx)), RigidTy::RawPtr(ty, mutability) => { - rustc_ty::TyKind::RawPtr(ty.internal(tables, cx), mutability.internal(tables, cx)) + rustc_ty::TyKind::RawPtr(ty.internal(tables, tcx), mutability.internal(tables, tcx)) } RigidTy::Ref(region, ty, mutability) => rustc_ty::TyKind::Ref( - region.internal(tables, cx), - ty.internal(tables, cx), - mutability.internal(tables, cx), + region.internal(tables, tcx), + ty.internal(tables, tcx), + mutability.internal(tables, tcx), ), - RigidTy::Foreign(def) => rustc_ty::TyKind::Foreign(def.0.internal(tables, cx)), + RigidTy::Foreign(def) => rustc_ty::TyKind::Foreign(def.0.internal(tables, tcx)), RigidTy::FnDef(def, args) => { - rustc_ty::TyKind::FnDef(def.0.internal(tables, cx), args.internal(tables, cx)) + rustc_ty::TyKind::FnDef(def.0.internal(tables, tcx), args.internal(tables, tcx)) } RigidTy::FnPtr(sig) => { - let (sig_tys, hdr) = sig.internal(tables, cx).split(); + let (sig_tys, hdr) = sig.internal(tables, tcx).split(); rustc_ty::TyKind::FnPtr(sig_tys, hdr) } RigidTy::Closure(def, args) => { - rustc_ty::TyKind::Closure(def.0.internal(tables, cx), args.internal(tables, cx)) + rustc_ty::TyKind::Closure(def.0.internal(tables, tcx), args.internal(tables, tcx)) } RigidTy::Coroutine(def, args, _mov) => { - rustc_ty::TyKind::Coroutine(def.0.internal(tables, cx), args.internal(tables, cx)) + rustc_ty::TyKind::Coroutine(def.0.internal(tables, tcx), args.internal(tables, tcx)) } RigidTy::CoroutineClosure(def, args) => rustc_ty::TyKind::CoroutineClosure( - def.0.internal(tables, cx), - args.internal(tables, cx), + def.0.internal(tables, tcx), + args.internal(tables, tcx), ), RigidTy::CoroutineWitness(def, args) => rustc_ty::TyKind::CoroutineWitness( - def.0.internal(tables, cx), - args.internal(tables, cx), + def.0.internal(tables, tcx), + args.internal(tables, tcx), ), RigidTy::Dynamic(predicate, region, dyn_kind) => rustc_ty::TyKind::Dynamic( - cx.mk_poly_existential_predicates(&predicate.internal(tables, cx)), - region.internal(tables, cx), - dyn_kind.internal(tables, cx), + tcx.mk_poly_existential_predicates(&predicate.internal(tables, tcx)), + region.internal(tables, tcx), + dyn_kind.internal(tables, tcx), ), RigidTy::Tuple(tys) => { - rustc_ty::TyKind::Tuple(cx.mk_type_list(&tys.internal(tables, cx))) + rustc_ty::TyKind::Tuple(tcx.mk_type_list(&tys.internal(tables, tcx))) } } } @@ -210,7 +209,7 @@ impl RustcInternal for IntTy { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { IntTy::Isize => rustc_ty::IntTy::Isize, @@ -229,7 +228,7 @@ impl RustcInternal for UintTy { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { UintTy::Usize => rustc_ty::UintTy::Usize, @@ -248,7 +247,7 @@ impl RustcInternal for FloatTy { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { FloatTy::F16 => rustc_ty::FloatTy::F16, @@ -265,7 +264,7 @@ impl RustcInternal for Mutability { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { Mutability::Not => rustc_ty::Mutability::Not, @@ -280,7 +279,7 @@ impl RustcInternal for Movability { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { Movability::Static => rustc_ty::Movability::Static, @@ -295,7 +294,7 @@ impl RustcInternal for RawPtrKind { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { RawPtrKind::Mut => rustc_middle::mir::RawPtrKind::Mut, @@ -311,13 +310,13 @@ impl RustcInternal for FnSig { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - cx.lift(rustc_ty::FnSig { - inputs_and_output: cx.mk_type_list(&self.inputs_and_output.internal(tables, cx)), + tcx.lift(rustc_ty::FnSig { + inputs_and_output: tcx.mk_type_list(&self.inputs_and_output.internal(tables, tcx)), c_variadic: self.c_variadic, - safety: self.safety.internal(tables, cx), - abi: self.abi.internal(tables, cx), + safety: self.safety.internal(tables, tcx), + abi: self.abi.internal(tables, tcx), }) .unwrap() } @@ -329,7 +328,7 @@ impl RustcInternal for VariantIdx { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { rustc_abi::VariantIdx::from(self.to_index()) } @@ -341,9 +340,9 @@ impl RustcInternal for VariantDef { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - self.adt_def.internal(tables, cx).variant(self.idx.internal(tables, cx)) + self.adt_def.internal(tables, tcx).variant(self.idx.internal(tables, tcx)) } } @@ -352,21 +351,21 @@ impl RustcInternal for MirConst { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { let constant = tables.mir_consts[self.id]; match constant { rustc_middle::mir::Const::Ty(ty, ct) => { - rustc_middle::mir::Const::Ty(cx.lift(ty).unwrap(), cx.lift(ct).unwrap()) + rustc_middle::mir::Const::Ty(tcx.lift(ty).unwrap(), tcx.lift(ct).unwrap()) } rustc_middle::mir::Const::Unevaluated(uneval, ty) => { rustc_middle::mir::Const::Unevaluated( - cx.lift(uneval).unwrap(), - cx.lift(ty).unwrap(), + tcx.lift(uneval).unwrap(), + tcx.lift(ty).unwrap(), ) } rustc_middle::mir::Const::Val(const_val, ty) => { - rustc_middle::mir::Const::Val(cx.lift(const_val).unwrap(), cx.lift(ty).unwrap()) + rustc_middle::mir::Const::Val(tcx.lift(const_val).unwrap(), tcx.lift(ty).unwrap()) } } } @@ -378,12 +377,12 @@ impl RustcInternal for MonoItem { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { use rustc_middle::mir::mono as rustc_mono; match self { - MonoItem::Fn(instance) => rustc_mono::MonoItem::Fn(instance.internal(tables, cx)), - MonoItem::Static(def) => rustc_mono::MonoItem::Static(def.internal(tables, cx)), + MonoItem::Fn(instance) => rustc_mono::MonoItem::Fn(instance.internal(tables, tcx)), + MonoItem::Static(def) => rustc_mono::MonoItem::Static(def.internal(tables, tcx)), MonoItem::GlobalAsm(_) => { unimplemented!() } @@ -397,9 +396,9 @@ impl RustcInternal for Instance { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - cx.lift(tables.instances[self.def]).unwrap() + tcx.lift(tables.instances[self.def]).unwrap() } } @@ -409,9 +408,9 @@ impl RustcInternal for StaticDef { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - self.0.internal(tables, cx) + self.0.internal(tables, tcx) } } @@ -426,12 +425,12 @@ where fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { rustc_ty::Binder::bind_with_vars( - self.value.internal(tables, cx), - cx.mk_bound_variable_kinds_from_iter( - self.bound_vars.iter().map(|bound| bound.internal(tables, cx)), + self.value.internal(tables, tcx), + tcx.mk_bound_variable_kinds_from_iter( + self.bound_vars.iter().map(|bound| bound.internal(tables, tcx)), ), ) } @@ -443,19 +442,19 @@ impl RustcInternal for BoundVariableKind { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { BoundVariableKind::Ty(kind) => rustc_ty::BoundVariableKind::Ty(match kind { BoundTyKind::Anon => rustc_ty::BoundTyKind::Anon, BoundTyKind::Param(def, symbol) => { - rustc_ty::BoundTyKind::Param(def.0.internal(tables, cx), Symbol::intern(symbol)) + rustc_ty::BoundTyKind::Param(def.0.internal(tables, tcx), Symbol::intern(symbol)) } }), BoundVariableKind::Region(kind) => rustc_ty::BoundVariableKind::Region(match kind { BoundRegionKind::BrAnon => rustc_ty::BoundRegionKind::Anon, BoundRegionKind::BrNamed(def, symbol) => rustc_ty::BoundRegionKind::Named( - def.0.internal(tables, cx), + def.0.internal(tables, tcx), Symbol::intern(symbol), ), BoundRegionKind::BrEnv => rustc_ty::BoundRegionKind::ClosureEnv, @@ -471,7 +470,7 @@ impl RustcInternal for DynKind { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { DynKind::Dyn => rustc_ty::DynKind::Dyn, @@ -486,17 +485,17 @@ impl RustcInternal for ExistentialPredicate { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { ExistentialPredicate::Trait(trait_ref) => { - rustc_ty::ExistentialPredicate::Trait(trait_ref.internal(tables, cx)) + rustc_ty::ExistentialPredicate::Trait(trait_ref.internal(tables, tcx)) } ExistentialPredicate::Projection(proj) => { - rustc_ty::ExistentialPredicate::Projection(proj.internal(tables, cx)) + rustc_ty::ExistentialPredicate::Projection(proj.internal(tables, tcx)) } ExistentialPredicate::AutoTrait(trait_def) => { - rustc_ty::ExistentialPredicate::AutoTrait(trait_def.0.internal(tables, cx)) + rustc_ty::ExistentialPredicate::AutoTrait(trait_def.0.internal(tables, tcx)) } } } @@ -508,13 +507,13 @@ impl RustcInternal for ExistentialProjection { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { use rustc_smir::context::SmirExistentialProjection; - cx.new_from_args( - self.def_id.0.internal(tables, cx), - self.generic_args.internal(tables, cx), - self.term.internal(tables, cx), + tcx.new_from_args( + self.def_id.0.internal(tables, tcx), + self.generic_args.internal(tables, tcx), + self.term.internal(tables, tcx), ) } } @@ -525,11 +524,11 @@ impl RustcInternal for TermKind { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { - TermKind::Type(ty) => ty.internal(tables, cx).into(), - TermKind::Const(cnst) => cnst.internal(tables, cx).into(), + TermKind::Type(ty) => ty.internal(tables, tcx).into(), + TermKind::Const(cnst) => cnst.internal(tables, tcx).into(), } } } @@ -540,10 +539,10 @@ impl RustcInternal for ExistentialTraitRef { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { use rustc_smir::context::SmirExistentialTraitRef; - cx.new_from_args(self.def_id.0.internal(tables, cx), self.generic_args.internal(tables, cx)) + tcx.new_from_args(self.def_id.0.internal(tables, tcx), self.generic_args.internal(tables, tcx)) } } @@ -553,10 +552,10 @@ impl RustcInternal for TraitRef { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { use rustc_smir::context::SmirTraitRef; - cx.new_from_args(self.def_id.0.internal(tables, cx), self.args().internal(tables, cx)) + tcx.new_from_args(self.def_id.0.internal(tables, tcx), self.args().internal(tables, tcx)) } } @@ -565,9 +564,9 @@ impl RustcInternal for AllocId { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - cx.lift(tables.alloc_ids[*self]).unwrap() + tcx.lift(tables.alloc_ids[*self]).unwrap() } } @@ -577,7 +576,7 @@ impl RustcInternal for ClosureKind { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { ClosureKind::Fn => rustc_ty::ClosureKind::Fn, @@ -592,9 +591,9 @@ impl RustcInternal for AdtDef { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - cx.adt_def(self.0.internal(tables, cx)) + InternalCx::adt_def(tcx, self.0.internal(tables, tcx)) } } @@ -604,7 +603,7 @@ impl RustcInternal for Abi { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match *self { Abi::Rust => rustc_abi::ExternAbi::Rust, @@ -643,7 +642,7 @@ impl RustcInternal for Safety { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { Safety::Unsafe => rustc_hir::Safety::Unsafe, @@ -657,7 +656,7 @@ impl RustcInternal for Span { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { tables.spans[*self] } @@ -669,9 +668,9 @@ impl RustcInternal for Layout { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - cx.lift(tables.layouts[*self]).unwrap() + tcx.lift(tables.layouts[*self]).unwrap() } } @@ -681,11 +680,11 @@ impl RustcInternal for Place { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { rustc_middle::mir::Place { local: rustc_middle::mir::Local::from_usize(self.local), - projection: cx.mk_place_elems(&self.projection.internal(tables, cx)), + projection: tcx.mk_place_elems(&self.projection.internal(tables, tcx)), } } } @@ -696,12 +695,12 @@ impl RustcInternal for ProjectionElem { fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { ProjectionElem::Deref => rustc_middle::mir::PlaceElem::Deref, ProjectionElem::Field(idx, ty) => { - rustc_middle::mir::PlaceElem::Field((*idx).into(), ty.internal(tables, cx)) + rustc_middle::mir::PlaceElem::Field((*idx).into(), ty.internal(tables, tcx)) } ProjectionElem::Index(idx) => rustc_middle::mir::PlaceElem::Index((*idx).into()), ProjectionElem::ConstantIndex { offset, min_length, from_end } => { @@ -715,13 +714,13 @@ impl RustcInternal for ProjectionElem { rustc_middle::mir::PlaceElem::Subslice { from: *from, to: *to, from_end: *from_end } } ProjectionElem::Downcast(idx) => { - rustc_middle::mir::PlaceElem::Downcast(None, idx.internal(tables, cx)) + rustc_middle::mir::PlaceElem::Downcast(None, idx.internal(tables, tcx)) } ProjectionElem::OpaqueCast(ty) => { - rustc_middle::mir::PlaceElem::OpaqueCast(ty.internal(tables, cx)) + rustc_middle::mir::PlaceElem::OpaqueCast(ty.internal(tables, tcx)) } ProjectionElem::Subtype(ty) => { - rustc_middle::mir::PlaceElem::Subtype(ty.internal(tables, cx)) + rustc_middle::mir::PlaceElem::Subtype(ty.internal(tables, tcx)) } } } @@ -733,7 +732,7 @@ impl RustcInternal for BinOp { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { BinOp::Add => rustc_middle::mir::BinOp::Add, @@ -769,7 +768,7 @@ impl RustcInternal for UnOp { fn internal<'tcx>( &self, _tables: &mut Tables<'_, BridgeTys>, - _cx: &SmirCtxt<'tcx, BridgeTys>, + _tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { match self { UnOp::Not => rustc_middle::mir::UnOp::Not, @@ -788,9 +787,9 @@ where fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - (*self).internal(tables, cx) + (*self).internal(tables, tcx) } } @@ -803,9 +802,9 @@ where fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - self.as_ref().map(|inner| inner.internal(tables, cx)) + self.as_ref().map(|inner| inner.internal(tables, tcx)) } } @@ -818,8 +817,8 @@ where fn internal<'tcx>( &self, tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { - self.iter().map(|e| e.internal(tables, cx)).collect() + self.iter().map(|e| e.internal(tables, tcx)).collect() } } diff --git a/compiler/rustc_smir/src/stable_mir/unstable/mod.rs b/compiler/rustc_smir/src/stable_mir/unstable/mod.rs new file mode 100644 index 0000000000000..6163aeb1d6ea8 --- /dev/null +++ b/compiler/rustc_smir/src/stable_mir/unstable/mod.rs @@ -0,0 +1,208 @@ +//! Module that collects the things that have no stability guarantees. +//! +//! We want to keep StableMIR definitions and logic separate from +//! any sort of conversion and usage of internal rustc code. So we +//! restrict the usage of internal items to be inside this module. + +use rustc_hir::def::DefKind; +use rustc_middle::ty::{List, Ty, TyCtxt}; +use rustc_middle::{mir, ty}; +use rustc_smir::Tables; +use rustc_smir::context::{SmirCtxt, SmirExistentialProjection, SmirExistentialTraitRef, SmirTraitRef}; + +use stable_mir::{CtorKind, ItemKind}; + +use crate::{rustc_smir, stable_mir}; + +use super::compiler_interface::BridgeTys; + +pub(crate) mod convert; + +impl<'tcx, T: InternalCx<'tcx>> SmirExistentialProjection<'tcx> for T { + 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, T: InternalCx<'tcx>> SmirExistentialTraitRef<'tcx> for T { + fn new_from_args( + &self, + trait_def_id: rustc_span::def_id::DefId, + args: ty::GenericArgsRef<'tcx>, + ) -> ty::ExistentialTraitRef<'tcx> { + ty::ExistentialTraitRef::new_from_args(self.tcx(), trait_def_id, args) + } +} + +impl<'tcx, T: InternalCx<'tcx>> SmirTraitRef<'tcx> for T { + fn new_from_args( + &self, + trait_def_id: rustc_span::def_id::DefId, + args: ty::GenericArgsRef<'tcx>, + ) -> ty::TraitRef<'tcx> { + ty::TraitRef::new_from_args(self.tcx(), trait_def_id, args) + } +} + +impl<'tcx> InternalCx<'tcx> for TyCtxt<'tcx> { + fn tcx(self) -> TyCtxt<'tcx> { + self + } + + fn lift>>(self, value: T) -> Option { + TyCtxt::lift(self, value) + } + + fn mk_args_from_iter(self, iter: I) -> T::Output + where + I: Iterator, + T: ty::CollectAndApply, ty::GenericArgsRef<'tcx>>, + { + TyCtxt::mk_args_from_iter(self, iter) + } + + fn mk_pat(self, v: ty::PatternKind<'tcx>) -> ty::Pattern<'tcx> { + TyCtxt::mk_pat(self, v) + } + + fn mk_poly_existential_predicates( + self, + eps: &[ty::PolyExistentialPredicate<'tcx>], + ) -> &'tcx List> { + TyCtxt::mk_poly_existential_predicates(self, eps) + } + + fn mk_type_list(self, v: &[Ty<'tcx>]) -> &'tcx List> { + TyCtxt::mk_type_list(self, v) + } + + fn lifetimes_re_erased(self) -> ty::Region<'tcx> { + self.lifetimes.re_erased + } + + fn mk_bound_variable_kinds_from_iter(self, iter: I) -> T::Output + where + I: Iterator, + T: ty::CollectAndApply>, + { + TyCtxt::mk_bound_variable_kinds_from_iter(self, iter) + } + + fn mk_place_elems(self, v: &[mir::PlaceElem<'tcx>]) -> &'tcx List> { + TyCtxt::mk_place_elems(self, v) + } + + fn adt_def(self, def_id: rustc_hir::def_id::DefId) -> ty::AdtDef<'tcx> { + self.adt_def(def_id) + } +} + +/// Trait that defines the methods that are fine to call from [`RustcInternal`]. +/// +/// This trait is only for [`RustcInternal`]. Any other other access to rustc's internals +/// should go through [`crate::rustc_smir::context::SmirCtxt`]. +pub trait InternalCx<'tcx> : Copy + Clone { + fn tcx(self) -> TyCtxt<'tcx>; + + fn lift>>(self, value: T) -> Option; + + fn mk_args_from_iter(self, iter: I) -> T::Output + where + I: Iterator, + T: ty::CollectAndApply, ty::GenericArgsRef<'tcx>>; + + fn mk_pat(self, v: ty::PatternKind<'tcx>) -> ty::Pattern<'tcx>; + + fn mk_poly_existential_predicates( + self, + eps: &[ty::PolyExistentialPredicate<'tcx>], + ) -> &'tcx List>; + + fn mk_type_list(self, v: &[Ty<'tcx>]) -> &'tcx List>; + + fn lifetimes_re_erased(self) -> ty::Region<'tcx>; + + fn mk_bound_variable_kinds_from_iter(self, iter: I) -> T::Output + where + I: Iterator, + T: ty::CollectAndApply>; + + fn mk_place_elems(self, v: &[mir::PlaceElem<'tcx>]) -> &'tcx List>; + + fn adt_def(self, def_id: rustc_hir::def_id::DefId) -> ty::AdtDef<'tcx>; +} + +/// Trait used to convert between an internal MIR type to a Stable MIR type. +/// +/// This trait is currently exposed to users so they can have interoperability between internal MIR +/// and StableMIR constructs. However, they should be used seldomly and they have no influence +/// in this crate semver. +#[doc(hidden)] +pub trait Stable<'tcx> { + /// The stable representation of the type implementing Stable. + type T; + /// Converts an object to the equivalent Stable MIR representation. + fn stable<'cx>( + &self, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, + ) -> Self::T; +} + +/// Trait used to translate a stable construct to its rustc counterpart. +/// +/// This is basically a mirror of [Stable]. +/// +/// This trait is currently exposed to users so they can have interoperability between internal MIR +/// and StableMIR constructs. They should be used seldomly as they have stability guarantees. +#[doc(hidden)] +pub trait RustcInternal { + type T<'tcx>; + fn internal<'tcx>( + &self, + tables: &mut Tables<'_, BridgeTys>, + tcx: impl InternalCx<'tcx>, + ) -> Self::T<'tcx>; +} + +pub(crate) fn new_item_kind(kind: DefKind) -> ItemKind { + match kind { + DefKind::Mod + | DefKind::Struct + | DefKind::Union + | DefKind::Enum + | DefKind::Variant + | DefKind::Trait + | DefKind::TyAlias + | DefKind::ForeignTy + | DefKind::TraitAlias + | DefKind::AssocTy + | DefKind::TyParam + | DefKind::ConstParam + | DefKind::Macro(_) + | DefKind::ExternCrate + | DefKind::Use + | DefKind::ForeignMod + | DefKind::OpaqueTy + | DefKind::Field + | DefKind::LifetimeParam + | DefKind::Impl { .. } + | DefKind::GlobalAsm => { + unreachable!("Not a valid item kind: {kind:?}"); + } + DefKind::Closure | DefKind::AssocFn | DefKind::Fn | DefKind::SyntheticCoroutineBody => { + ItemKind::Fn + } + DefKind::Const | DefKind::InlineConst | DefKind::AssocConst | DefKind::AnonConst => { + ItemKind::Const + } + DefKind::Static { .. } => ItemKind::Static, + DefKind::Ctor(_, rustc_hir::def::CtorKind::Const) => ItemKind::Ctor(CtorKind::Const), + DefKind::Ctor(_, rustc_hir::def::CtorKind::Fn) => ItemKind::Ctor(CtorKind::Fn), + } +} From 94c49ce45dbf9c562eca924e0585465eaf4969ae Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 9 Jun 2025 08:20:09 +0000 Subject: [PATCH 15/22] refactor: move `convert` to `unstable` We want to keep StableMIR definitions and logic separate from any sort of conversion and usage of internal rustc code. So we bundle all unstable items that have no stability guarantees into `stable_mir::unstable`. --- compiler/rustc_smir/src/rustc_internal/mod.rs | 2 +- compiler/rustc_smir/src/stable_mir/alloc.rs | 2 +- .../src/stable_mir/compiler_interface.rs | 4 +- compiler/rustc_smir/src/stable_mir/mod.rs | 42 +-- .../stable_mir/{ => unstable}/convert/mod.rs | 77 +++-- .../{ => unstable}/convert/stable/abi.rs | 94 +++--- .../{ => unstable}/convert/stable/mir.rs | 188 ++++++------ .../{ => unstable}/convert/stable/mod.rs | 20 +- .../{ => unstable}/convert/stable/ty.rs | 274 +++++++++--------- 9 files changed, 317 insertions(+), 386 deletions(-) rename compiler/rustc_smir/src/stable_mir/{ => unstable}/convert/mod.rs (51%) rename compiler/rustc_smir/src/stable_mir/{ => unstable}/convert/stable/abi.rs (83%) rename compiler/rustc_smir/src/stable_mir/{ => unstable}/convert/stable/mir.rs (89%) rename compiler/rustc_smir/src/stable_mir/{ => unstable}/convert/stable/mod.rs (80%) rename compiler/rustc_smir/src/stable_mir/{ => unstable}/convert/stable/ty.rs (85%) diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs index a8d2ab55d037b..dcdc77b76c216 100644 --- a/compiler/rustc_smir/src/rustc_internal/mod.rs +++ b/compiler/rustc_smir/src/rustc_internal/mod.rs @@ -9,7 +9,7 @@ use rustc_middle::ty::TyCtxt; use rustc_span::def_id::CrateNum; use scoped_tls::scoped_thread_local; use stable_mir::Error; -use stable_mir::convert::{RustcInternal, Stable}; +use stable_mir::unstable::{RustcInternal, Stable}; use crate::rustc_smir::context::SmirCtxt; use crate::rustc_smir::{Bridge, SmirContainer, Tables}; diff --git a/compiler/rustc_smir/src/stable_mir/alloc.rs b/compiler/rustc_smir/src/stable_mir/alloc.rs index 43c1ca49e19d0..954d4fe7ff40d 100644 --- a/compiler/rustc_smir/src/stable_mir/alloc.rs +++ b/compiler/rustc_smir/src/stable_mir/alloc.rs @@ -13,9 +13,9 @@ use rustc_smir::{Tables, alloc}; use super::Error; use super::compiler_interface::BridgeTys; -use super::convert::Stable; use super::mir::Mutability; use super::ty::{Allocation, ProvenanceMap}; +use super::unstable::Stable; use crate::rustc_smir; /// Creates new empty `Allocation` from given `Align`. diff --git a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs index 88b2f13173a9b..4f3deb00eb090 100644 --- a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs +++ b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs @@ -9,7 +9,6 @@ use rustc_hir::def::DefKind; use rustc_smir::context::SmirCtxt; use rustc_smir::{Bridge, SmirContainer}; use stable_mir::abi::{FnAbi, Layout, LayoutShape, ReprOptions}; -use stable_mir::convert::{RustcInternal, Stable}; use stable_mir::crate_def::Attribute; use stable_mir::mir::alloc::{AllocId, GlobalAlloc}; use stable_mir::mir::mono::{Instance, InstanceDef, StaticDef}; @@ -21,9 +20,10 @@ use stable_mir::ty::{ Generics, ImplDef, ImplTrait, IntrinsicDef, LineInfo, MirConst, PolyFnSig, RigidTy, Span, TraitDecl, TraitDef, Ty, TyConst, TyConstId, TyKind, UintTy, VariantDef, VariantIdx, }; +use stable_mir::unstable::{RustcInternal, Stable, new_item_kind}; use stable_mir::{ AssocItems, Crate, CrateDef, CrateItem, CrateItems, CrateNum, DefId, Error, Filename, - ImplTraitDecls, ItemKind, Symbol, TraitDecls, alloc, mir, new_item_kind, + ImplTraitDecls, ItemKind, Symbol, TraitDecls, alloc, mir, }; use tracing::debug; diff --git a/compiler/rustc_smir/src/stable_mir/mod.rs b/compiler/rustc_smir/src/stable_mir/mod.rs index 33213fcbe08e1..abb5e843e7718 100644 --- a/compiler/rustc_smir/src/stable_mir/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/mod.rs @@ -27,8 +27,7 @@ use std::fmt::Debug; use std::{fmt, io}; -use rustc_hir::def::DefKind; -use rustc_smir::IndexedVal; +pub(crate) use rustc_smir::IndexedVal; use serde::Serialize; use stable_mir::compiler_interface::with; pub use stable_mir::crate_def::{CrateDef, CrateDefItems, CrateDefType, DefId}; @@ -41,7 +40,7 @@ use crate::{rustc_smir, stable_mir}; pub mod abi; mod alloc; -pub(crate) mod convert; +pub(crate) mod unstable; #[macro_use] pub mod crate_def; pub mod compiler_interface; @@ -222,43 +221,6 @@ pub fn all_trait_impls() -> ImplTraitDecls { with(|cx| cx.all_trait_impls()) } -pub(crate) fn new_item_kind(kind: DefKind) -> ItemKind { - match kind { - DefKind::Mod - | DefKind::Struct - | DefKind::Union - | DefKind::Enum - | DefKind::Variant - | DefKind::Trait - | DefKind::TyAlias - | DefKind::ForeignTy - | DefKind::TraitAlias - | DefKind::AssocTy - | DefKind::TyParam - | DefKind::ConstParam - | DefKind::Macro(_) - | DefKind::ExternCrate - | DefKind::Use - | DefKind::ForeignMod - | DefKind::OpaqueTy - | DefKind::Field - | DefKind::LifetimeParam - | DefKind::Impl { .. } - | DefKind::GlobalAsm => { - unreachable!("Not a valid item kind: {kind:?}"); - } - DefKind::Closure | DefKind::AssocFn | DefKind::Fn | DefKind::SyntheticCoroutineBody => { - ItemKind::Fn - } - DefKind::Const | DefKind::InlineConst | DefKind::AssocConst | DefKind::AnonConst => { - ItemKind::Const - } - DefKind::Static { .. } => ItemKind::Static, - DefKind::Ctor(_, rustc_hir::def::CtorKind::Const) => ItemKind::Ctor(CtorKind::Const), - DefKind::Ctor(_, rustc_hir::def::CtorKind::Fn) => ItemKind::Ctor(CtorKind::Fn), - } -} - /// A type that provides internal information but that can still be used for debug purpose. #[derive(Clone, PartialEq, Eq, Hash, Serialize)] pub struct Opaque(String); diff --git a/compiler/rustc_smir/src/stable_mir/convert/mod.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/mod.rs similarity index 51% rename from compiler/rustc_smir/src/stable_mir/convert/mod.rs rename to compiler/rustc_smir/src/stable_mir/unstable/convert/mod.rs index 90ed67ed972b0..4c8a776d52978 100644 --- a/compiler/rustc_smir/src/stable_mir/convert/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/mod.rs @@ -1,10 +1,23 @@ +//! This module holds the logic to convert rustc internal ADTs into stable mir ADTs. +//! +//! The conversion from stable to internal is not meant to be complete, +//! and it should be added as when needed to be passed as input to rustc_smir functions. +//! +//! For contributors, please make sure to avoid calling rustc's internal functions and queries. +//! These should be done via `rustc_smir` APIs, but it's possible to access ADT fields directly. + use std::ops::RangeInclusive; + use rustc_smir::Tables; use rustc_smir::context::SmirCtxt; -use super::compiler_interface::BridgeTys; -use crate::rustc_smir; +use stable_mir::compiler_interface::BridgeTys; + +use crate::{rustc_smir, stable_mir}; + +use super::Stable; + mod internal; mod stable; @@ -15,10 +28,10 @@ where { type T = T::T; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { (*self).stable(tables, cx) } @@ -30,10 +43,10 @@ where { type T = Option; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { self.as_ref().map(|value| value.stable(tables, cx)) } @@ -46,10 +59,10 @@ where { type T = Result; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { Ok(val) => Ok(val.stable(tables, cx)), @@ -63,10 +76,10 @@ where T: Stable<'tcx>, { type T = Vec; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { self.iter().map(|e| e.stable(tables, cx)).collect() } @@ -78,10 +91,10 @@ where U: Stable<'tcx>, { type T = (T::T, U::T); - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { (self.0.stable(tables, cx), self.1.stable(tables, cx)) } @@ -92,35 +105,11 @@ where T: Stable<'tcx>, { type T = RangeInclusive; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { RangeInclusive::new(self.start().stable(tables, cx), self.end().stable(tables, cx)) } } - -/// Trait used to convert between an internal MIR type to a Stable MIR type. -pub trait Stable<'tcx> { - /// The stable representation of the type implementing Stable. - type T; - /// Converts an object to the equivalent Stable MIR representation. - fn stable( - &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, - ) -> Self::T; -} - -/// Trait used to translate a stable construct to its rustc counterpart. -/// -/// This is basically a mirror of [Stable]. -pub trait RustcInternal { - type T<'tcx>; - fn internal<'tcx>( - &self, - tables: &mut Tables<'_, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, - ) -> Self::T<'tcx>; -} diff --git a/compiler/rustc_smir/src/stable_mir/convert/stable/abi.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs similarity index 83% rename from compiler/rustc_smir/src/stable_mir/convert/stable/abi.rs rename to compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs index b6f02e1bc8f6b..02339730b27d3 100644 --- a/compiler/rustc_smir/src/stable_mir/convert/stable/abi.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs @@ -4,8 +4,8 @@ use rustc_abi::{ArmCall, CanonAbi, InterruptKind, X86Call}; use rustc_middle::ty; +use rustc_smir::Tables; use rustc_smir::context::SmirCtxt; -use rustc_smir::{IndexedVal, Tables}; use rustc_target::callconv; use stable_mir::abi::{ AddressSpace, ArgAbi, CallConvention, FieldsShape, FloatLength, FnAbi, IntegerLength, @@ -13,16 +13,16 @@ use stable_mir::abi::{ TagEncoding, TyAndLayout, ValueAbi, VariantsShape, WrappingRange, }; use stable_mir::compiler_interface::BridgeTys; -use stable_mir::convert::Stable; -use stable_mir::opaque; +use stable_mir::unstable::Stable; use stable_mir::target::MachineSize as Size; use stable_mir::ty::{Align, VariantIdx}; +use stable_mir::{IndexedVal, opaque}; use crate::{rustc_smir, stable_mir}; impl<'tcx> Stable<'tcx> for rustc_abi::VariantIdx { type T = VariantIdx; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { VariantIdx::to_val(self.as_usize()) } } @@ -30,7 +30,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::VariantIdx { impl<'tcx> Stable<'tcx> for rustc_abi::Endian { type T = stable_mir::target::Endian; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { rustc_abi::Endian::Little => stable_mir::target::Endian::Little, rustc_abi::Endian::Big => stable_mir::target::Endian::Big, @@ -41,10 +41,10 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Endian { impl<'tcx> Stable<'tcx> for rustc_abi::TyAndLayout<'tcx, ty::Ty<'tcx>> { type T = TyAndLayout; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { TyAndLayout { ty: self.ty.stable(tables, cx), layout: self.layout.stable(tables, cx) } } @@ -53,10 +53,10 @@ impl<'tcx> Stable<'tcx> for rustc_abi::TyAndLayout<'tcx, ty::Ty<'tcx>> { impl<'tcx> Stable<'tcx> for rustc_abi::Layout<'tcx> { type T = Layout; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { tables.layout_id(cx.lift(*self).unwrap()) } @@ -65,10 +65,10 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Layout<'tcx> { impl<'tcx> Stable<'tcx> for rustc_abi::LayoutData { type T = LayoutShape; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { LayoutShape { fields: self.fields.stable(tables, cx), @@ -83,10 +83,10 @@ impl<'tcx> Stable<'tcx> for rustc_abi::LayoutData Stable<'tcx> for callconv::FnAbi<'tcx, ty::Ty<'tcx>> { type T = FnAbi; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { assert!(self.args.len() >= self.fixed_count as usize); assert!(!self.c_variadic || matches!(self.conv, CanonAbi::C)); @@ -103,10 +103,10 @@ impl<'tcx> Stable<'tcx> for callconv::FnAbi<'tcx, ty::Ty<'tcx>> { impl<'tcx> Stable<'tcx> for callconv::ArgAbi<'tcx, ty::Ty<'tcx>> { type T = ArgAbi; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { ArgAbi { ty: self.layout.ty.stable(tables, cx), @@ -119,7 +119,7 @@ impl<'tcx> Stable<'tcx> for callconv::ArgAbi<'tcx, ty::Ty<'tcx>> { impl<'tcx> Stable<'tcx> for CanonAbi { type T = CallConvention; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { CanonAbi::C => CallConvention::C, CanonAbi::Rust => CallConvention::Rust, @@ -155,7 +155,7 @@ impl<'tcx> Stable<'tcx> for CanonAbi { impl<'tcx> Stable<'tcx> for callconv::PassMode { type T = PassMode; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { callconv::PassMode::Ignore => PassMode::Ignore, callconv::PassMode::Direct(attr) => PassMode::Direct(opaque(attr)), @@ -177,10 +177,10 @@ impl<'tcx> Stable<'tcx> for callconv::PassMode { impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape { type T = FieldsShape; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { rustc_abi::FieldsShape::Primitive => FieldsShape::Primitive, @@ -198,10 +198,10 @@ impl<'tcx> Stable<'tcx> for rustc_abi::FieldsShape { impl<'tcx> Stable<'tcx> for rustc_abi::Variants { type T = VariantsShape; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { rustc_abi::Variants::Single { index } => { @@ -212,7 +212,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Variants Stable<'tcx> for rustc_abi::Variants Stable<'tcx> for rustc_abi::TagEncoding { type T = TagEncoding; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { rustc_abi::TagEncoding::Direct => TagEncoding::Direct, @@ -244,10 +244,10 @@ impl<'tcx> Stable<'tcx> for rustc_abi::TagEncoding { impl<'tcx> Stable<'tcx> for rustc_abi::BackendRepr { type T = ValueAbi; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match *self { rustc_abi::BackendRepr::Scalar(scalar) => ValueAbi::Scalar(scalar.stable(tables, cx)), @@ -265,7 +265,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::BackendRepr { impl<'tcx> Stable<'tcx> for rustc_abi::Size { type T = Size; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { Size::from_bits(self.bits_usize()) } } @@ -273,7 +273,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Size { impl<'tcx> Stable<'tcx> for rustc_abi::Align { type T = Align; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { self.bytes() } } @@ -281,10 +281,10 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Align { impl<'tcx> Stable<'tcx> for rustc_abi::Scalar { type T = Scalar; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { rustc_abi::Scalar::Initialized { value, valid_range } => Scalar::Initialized { @@ -299,10 +299,10 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Scalar { impl<'tcx> Stable<'tcx> for rustc_abi::Primitive { type T = Primitive; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { rustc_abi::Primitive::Int(length, signed) => { @@ -319,7 +319,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Primitive { impl<'tcx> Stable<'tcx> for rustc_abi::AddressSpace { type T = AddressSpace; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { AddressSpace(self.0) } } @@ -327,7 +327,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::AddressSpace { impl<'tcx> Stable<'tcx> for rustc_abi::Integer { type T = IntegerLength; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { rustc_abi::Integer::I8 => IntegerLength::I8, rustc_abi::Integer::I16 => IntegerLength::I16, @@ -341,7 +341,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Integer { impl<'tcx> Stable<'tcx> for rustc_abi::Float { type T = FloatLength; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { rustc_abi::Float::F16 => FloatLength::F16, rustc_abi::Float::F32 => FloatLength::F32, @@ -354,7 +354,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Float { impl<'tcx> Stable<'tcx> for rustc_abi::WrappingRange { type T = WrappingRange; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { WrappingRange { start: self.start, end: self.end } } } diff --git a/compiler/rustc_smir/src/stable_mir/convert/stable/mir.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/mir.rs similarity index 89% rename from compiler/rustc_smir/src/stable_mir/convert/stable/mir.rs rename to compiler/rustc_smir/src/stable_mir/unstable/convert/stable/mir.rs index 98b828248354a..363c4eab4eb94 100644 --- a/compiler/rustc_smir/src/stable_mir/convert/stable/mir.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/mir.rs @@ -6,7 +6,7 @@ use rustc_smir::Tables; use rustc_smir::bridge::SmirError; use rustc_smir::context::SmirCtxt; use stable_mir::compiler_interface::BridgeTys; -use stable_mir::convert::Stable; +use stable_mir::unstable::Stable; use stable_mir::mir::alloc::GlobalAlloc; use stable_mir::mir::{ConstOperand, Statement, UserTypeProjection, VarDebugInfoFragment}; use stable_mir::ty::{Allocation, ConstantKind, MirConst}; @@ -17,10 +17,10 @@ use crate::{rustc_smir, stable_mir}; impl<'tcx> Stable<'tcx> for mir::Body<'tcx> { type T = stable_mir::mir::Body; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { stable_mir::mir::Body::new( self.basic_blocks @@ -52,10 +52,10 @@ impl<'tcx> Stable<'tcx> for mir::Body<'tcx> { impl<'tcx> Stable<'tcx> for mir::VarDebugInfo<'tcx> { type T = stable_mir::mir::VarDebugInfo; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { stable_mir::mir::VarDebugInfo { name: self.name.to_string(), @@ -69,10 +69,10 @@ impl<'tcx> Stable<'tcx> for mir::VarDebugInfo<'tcx> { impl<'tcx> Stable<'tcx> for mir::Statement<'tcx> { type T = stable_mir::mir::Statement; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { Statement { kind: self.kind.stable(tables, cx), @@ -83,10 +83,10 @@ impl<'tcx> Stable<'tcx> for mir::Statement<'tcx> { impl<'tcx> Stable<'tcx> for mir::SourceInfo { type T = stable_mir::mir::SourceInfo; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { stable_mir::mir::SourceInfo { span: self.span.stable(tables, cx), scope: self.scope.into() } } @@ -94,10 +94,10 @@ impl<'tcx> Stable<'tcx> for mir::SourceInfo { impl<'tcx> Stable<'tcx> for mir::VarDebugInfoFragment<'tcx> { type T = stable_mir::mir::VarDebugInfoFragment; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { VarDebugInfoFragment { ty: self.ty.stable(tables, cx), @@ -108,10 +108,10 @@ impl<'tcx> Stable<'tcx> for mir::VarDebugInfoFragment<'tcx> { impl<'tcx> Stable<'tcx> for mir::VarDebugInfoContents<'tcx> { type T = stable_mir::mir::VarDebugInfoContents; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { mir::VarDebugInfoContents::Place(place) => { @@ -131,10 +131,10 @@ impl<'tcx> Stable<'tcx> for mir::VarDebugInfoContents<'tcx> { impl<'tcx> Stable<'tcx> for mir::StatementKind<'tcx> { type T = stable_mir::mir::StatementKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { mir::StatementKind::Assign(assign) => stable_mir::mir::StatementKind::Assign( @@ -198,10 +198,10 @@ impl<'tcx> Stable<'tcx> for mir::StatementKind<'tcx> { impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> { type T = stable_mir::mir::Rvalue; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::mir::Rvalue::*; match self { @@ -267,7 +267,7 @@ impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> { impl<'tcx> Stable<'tcx> for mir::Mutability { type T = stable_mir::mir::Mutability; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_hir::Mutability::*; match *self { Not => stable_mir::mir::Mutability::Not, @@ -278,7 +278,7 @@ impl<'tcx> Stable<'tcx> for mir::Mutability { impl<'tcx> Stable<'tcx> for mir::RawPtrKind { type T = stable_mir::mir::RawPtrKind; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use mir::RawPtrKind::*; match *self { Const => stable_mir::mir::RawPtrKind::Const, @@ -290,10 +290,10 @@ impl<'tcx> Stable<'tcx> for mir::RawPtrKind { impl<'tcx> Stable<'tcx> for mir::BorrowKind { type T = stable_mir::mir::BorrowKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::mir::BorrowKind::*; match *self { @@ -306,7 +306,7 @@ impl<'tcx> Stable<'tcx> for mir::BorrowKind { impl<'tcx> Stable<'tcx> for mir::MutBorrowKind { type T = stable_mir::mir::MutBorrowKind; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::mir::MutBorrowKind::*; match *self { Default => stable_mir::mir::MutBorrowKind::Default, @@ -318,7 +318,7 @@ impl<'tcx> Stable<'tcx> for mir::MutBorrowKind { impl<'tcx> Stable<'tcx> for mir::FakeBorrowKind { type T = stable_mir::mir::FakeBorrowKind; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::mir::FakeBorrowKind::*; match *self { Deep => stable_mir::mir::FakeBorrowKind::Deep, @@ -329,10 +329,10 @@ impl<'tcx> Stable<'tcx> for mir::FakeBorrowKind { impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> { type T = stable_mir::mir::NullOp; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::mir::NullOp::*; match self { @@ -349,10 +349,10 @@ impl<'tcx> Stable<'tcx> for mir::NullOp<'tcx> { impl<'tcx> Stable<'tcx> for mir::CastKind { type T = stable_mir::mir::CastKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::mir::CastKind::*; use rustc_middle::ty::adjustment::PointerCoercion; @@ -376,7 +376,7 @@ impl<'tcx> Stable<'tcx> for mir::CastKind { impl<'tcx> Stable<'tcx> for mir::FakeReadCause { type T = stable_mir::mir::FakeReadCause; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::mir::FakeReadCause::*; match self { ForMatchGuard => stable_mir::mir::FakeReadCause::ForMatchGuard, @@ -392,10 +392,10 @@ impl<'tcx> Stable<'tcx> for mir::FakeReadCause { impl<'tcx> Stable<'tcx> for mir::Operand<'tcx> { type T = stable_mir::mir::Operand; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::mir::Operand::*; match self { @@ -409,10 +409,10 @@ impl<'tcx> Stable<'tcx> for mir::Operand<'tcx> { impl<'tcx> Stable<'tcx> for mir::ConstOperand<'tcx> { type T = stable_mir::mir::ConstOperand; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { stable_mir::mir::ConstOperand { span: self.span.stable(tables, cx), @@ -424,10 +424,10 @@ impl<'tcx> Stable<'tcx> for mir::ConstOperand<'tcx> { impl<'tcx> Stable<'tcx> for mir::Place<'tcx> { type T = stable_mir::mir::Place; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { stable_mir::mir::Place { local: self.local.as_usize(), @@ -438,10 +438,10 @@ impl<'tcx> Stable<'tcx> for mir::Place<'tcx> { impl<'tcx> Stable<'tcx> for mir::PlaceElem<'tcx> { type T = stable_mir::mir::ProjectionElem; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::mir::ProjectionElem::*; match self { @@ -479,21 +479,21 @@ impl<'tcx> Stable<'tcx> for mir::PlaceElem<'tcx> { impl<'tcx> Stable<'tcx> for mir::UserTypeProjection { type T = stable_mir::mir::UserTypeProjection; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { UserTypeProjection { base: self.base.as_usize(), projection: opaque(&self.projs) } } } impl<'tcx> Stable<'tcx> for mir::Local { type T = stable_mir::mir::Local; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { self.as_usize() } } impl<'tcx> Stable<'tcx> for mir::RetagKind { type T = stable_mir::mir::RetagKind; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::mir::RetagKind; match self { RetagKind::FnEntry => stable_mir::mir::RetagKind::FnEntry, @@ -506,7 +506,7 @@ impl<'tcx> Stable<'tcx> for mir::RetagKind { impl<'tcx> Stable<'tcx> for mir::UnwindAction { type T = stable_mir::mir::UnwindAction; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::mir::UnwindAction; match self { UnwindAction::Continue => stable_mir::mir::UnwindAction::Continue, @@ -520,10 +520,10 @@ impl<'tcx> Stable<'tcx> for mir::UnwindAction { impl<'tcx> Stable<'tcx> for mir::NonDivergingIntrinsic<'tcx> { type T = stable_mir::mir::NonDivergingIntrinsic; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::mir::NonDivergingIntrinsic; use stable_mir::mir::CopyNonOverlapping; @@ -544,10 +544,10 @@ impl<'tcx> Stable<'tcx> for mir::NonDivergingIntrinsic<'tcx> { impl<'tcx> Stable<'tcx> for mir::AssertMessage<'tcx> { type T = stable_mir::mir::AssertMessage; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::mir::AssertKind; match self { @@ -593,7 +593,7 @@ impl<'tcx> Stable<'tcx> for mir::AssertMessage<'tcx> { impl<'tcx> Stable<'tcx> for mir::BinOp { type T = stable_mir::mir::BinOp; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::mir::BinOp; match self { BinOp::Add => stable_mir::mir::BinOp::Add, @@ -628,7 +628,7 @@ impl<'tcx> Stable<'tcx> for mir::BinOp { impl<'tcx> Stable<'tcx> for mir::UnOp { type T = stable_mir::mir::UnOp; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::mir::UnOp; match self { UnOp::Not => stable_mir::mir::UnOp::Not, @@ -640,10 +640,10 @@ impl<'tcx> Stable<'tcx> for mir::UnOp { impl<'tcx> Stable<'tcx> for mir::AggregateKind<'tcx> { type T = stable_mir::mir::AggregateKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { mir::AggregateKind::Array(ty) => { @@ -688,10 +688,10 @@ impl<'tcx> Stable<'tcx> for mir::AggregateKind<'tcx> { impl<'tcx> Stable<'tcx> for mir::InlineAsmOperand<'tcx> { type T = stable_mir::mir::InlineAsmOperand; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::mir::InlineAsmOperand; @@ -715,10 +715,10 @@ impl<'tcx> Stable<'tcx> for mir::InlineAsmOperand<'tcx> { impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> { type T = stable_mir::mir::Terminator; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::mir::Terminator; Terminator { @@ -730,10 +730,10 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> { impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> { type T = stable_mir::mir::TerminatorKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::mir::TerminatorKind; match self { @@ -819,10 +819,10 @@ impl<'tcx> Stable<'tcx> for mir::TerminatorKind<'tcx> { impl<'tcx> Stable<'tcx> for mir::interpret::ConstAllocation<'tcx> { type T = Allocation; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { self.inner().stable(tables, cx) } @@ -831,10 +831,10 @@ impl<'tcx> Stable<'tcx> for mir::interpret::ConstAllocation<'tcx> { impl<'tcx> Stable<'tcx> for mir::interpret::Allocation { type T = stable_mir::ty::Allocation; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_smir::context::SmirAllocRange; alloc::allocation_filter( @@ -848,11 +848,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::Allocation { impl<'tcx> Stable<'tcx> for mir::interpret::AllocId { type T = stable_mir::mir::alloc::AllocId; - fn stable( - &self, - tables: &mut Tables<'tcx, BridgeTys>, - _: &SmirCtxt<'tcx, BridgeTys>, - ) -> Self::T { + fn stable<'cx>(&self, tables: &mut Tables<'cx, BridgeTys>, _: &SmirCtxt<'cx, BridgeTys>) -> Self::T { tables.create_alloc_id(*self) } } @@ -860,10 +856,10 @@ impl<'tcx> Stable<'tcx> for mir::interpret::AllocId { impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> { type T = GlobalAlloc; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { mir::interpret::GlobalAlloc::Function { instance, .. } => { @@ -886,10 +882,10 @@ impl<'tcx> Stable<'tcx> for mir::interpret::GlobalAlloc<'tcx> { impl<'tcx> Stable<'tcx> for rustc_middle::mir::Const<'tcx> { type T = stable_mir::ty::MirConst; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let id = tables.intern_mir_const(cx.lift(*self).unwrap()); match *self { @@ -926,7 +922,7 @@ impl<'tcx> Stable<'tcx> for rustc_middle::mir::Const<'tcx> { impl<'tcx> Stable<'tcx> for mir::interpret::ErrorHandled { type T = Error; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { Error::new(format!("{self:?}")) } } @@ -934,10 +930,10 @@ impl<'tcx> Stable<'tcx> for mir::interpret::ErrorHandled { impl<'tcx> Stable<'tcx> for MonoItem<'tcx> { type T = stable_mir::mir::mono::MonoItem; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::mir::mono::MonoItem as StableMonoItem; match self { diff --git a/compiler/rustc_smir/src/stable_mir/convert/stable/mod.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/mod.rs similarity index 80% rename from compiler/rustc_smir/src/stable_mir/convert/stable/mod.rs rename to compiler/rustc_smir/src/stable_mir/unstable/convert/stable/mod.rs index 1cead1c3c37bc..bd6542394dc8c 100644 --- a/compiler/rustc_smir/src/stable_mir/convert/stable/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/mod.rs @@ -14,7 +14,7 @@ mod ty; impl<'tcx> Stable<'tcx> for rustc_hir::Safety { type T = stable_mir::mir::Safety; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { rustc_hir::Safety::Unsafe => stable_mir::mir::Safety::Unsafe, rustc_hir::Safety::Safe => stable_mir::mir::Safety::Safe, @@ -24,14 +24,14 @@ impl<'tcx> Stable<'tcx> for rustc_hir::Safety { impl<'tcx> Stable<'tcx> for FieldIdx { type T = usize; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { self.as_usize() } } impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineSource { type T = stable_mir::mir::CoroutineSource; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_hir::CoroutineSource; match self { CoroutineSource::Block => stable_mir::mir::CoroutineSource::Block, @@ -43,10 +43,10 @@ impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineSource { impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineKind { type T = stable_mir::mir::CoroutineKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_hir::{CoroutineDesugaring, CoroutineKind}; match *self { @@ -78,7 +78,7 @@ impl<'tcx> Stable<'tcx> for rustc_hir::CoroutineKind { impl<'tcx> Stable<'tcx> for rustc_span::Symbol { type T = stable_mir::Symbol; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { self.to_string() } } @@ -86,11 +86,7 @@ impl<'tcx> Stable<'tcx> for rustc_span::Symbol { impl<'tcx> Stable<'tcx> for rustc_span::Span { type T = stable_mir::ty::Span; - fn stable( - &self, - tables: &mut Tables<'tcx, BridgeTys>, - _: &SmirCtxt<'tcx, BridgeTys>, - ) -> Self::T { + fn stable<'cx>(&self, tables: &mut Tables<'cx, BridgeTys>, _: &SmirCtxt<'cx, BridgeTys>) -> Self::T { tables.create_span(*self) } } diff --git a/compiler/rustc_smir/src/stable_mir/convert/stable/ty.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs similarity index 85% rename from compiler/rustc_smir/src/stable_mir/convert/stable/ty.rs rename to compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs index 89df7e2fdc5d5..c05bcb993b1cc 100644 --- a/compiler/rustc_smir/src/stable_mir/convert/stable/ty.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs @@ -6,7 +6,7 @@ use rustc_smir::Tables; use rustc_smir::context::SmirCtxt; use stable_mir::alloc; use stable_mir::compiler_interface::BridgeTys; -use stable_mir::convert::Stable; +use stable_mir::unstable::Stable; use stable_mir::ty::{ AdtKind, FloatTy, GenericArgs, GenericParamDef, IntTy, Region, RigidTy, TyKind, UintTy, }; @@ -15,7 +15,7 @@ use crate::{rustc_smir, stable_mir}; impl<'tcx> Stable<'tcx> for ty::AliasTyKind { type T = stable_mir::ty::AliasKind; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { ty::Projection => stable_mir::ty::AliasKind::Projection, ty::Inherent => stable_mir::ty::AliasKind::Inherent, @@ -27,10 +27,10 @@ impl<'tcx> Stable<'tcx> for ty::AliasTyKind { impl<'tcx> Stable<'tcx> for ty::AliasTy<'tcx> { type T = stable_mir::ty::AliasTy; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let ty::AliasTy { args, def_id, .. } = self; stable_mir::ty::AliasTy { def_id: tables.alias_def(*def_id), args: args.stable(tables, cx) } @@ -39,10 +39,10 @@ impl<'tcx> Stable<'tcx> for ty::AliasTy<'tcx> { impl<'tcx> Stable<'tcx> for ty::AliasTerm<'tcx> { type T = stable_mir::ty::AliasTerm; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let ty::AliasTerm { args, def_id, .. } = self; stable_mir::ty::AliasTerm { @@ -55,7 +55,7 @@ impl<'tcx> Stable<'tcx> for ty::AliasTerm<'tcx> { impl<'tcx> Stable<'tcx> for ty::DynKind { type T = stable_mir::ty::DynKind; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { ty::Dyn => stable_mir::ty::DynKind::Dyn, ty::DynStar => stable_mir::ty::DynKind::DynStar, @@ -66,10 +66,10 @@ impl<'tcx> Stable<'tcx> for ty::DynKind { impl<'tcx> Stable<'tcx> for ty::ExistentialPredicate<'tcx> { type T = stable_mir::ty::ExistentialPredicate; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::ExistentialPredicate::*; match self { @@ -87,10 +87,10 @@ impl<'tcx> Stable<'tcx> for ty::ExistentialPredicate<'tcx> { impl<'tcx> Stable<'tcx> for ty::ExistentialTraitRef<'tcx> { type T = stable_mir::ty::ExistentialTraitRef; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let ty::ExistentialTraitRef { def_id, args, .. } = self; stable_mir::ty::ExistentialTraitRef { @@ -103,10 +103,10 @@ impl<'tcx> Stable<'tcx> for ty::ExistentialTraitRef<'tcx> { impl<'tcx> Stable<'tcx> for ty::TermKind<'tcx> { type T = stable_mir::ty::TermKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::TermKind; match self { @@ -122,10 +122,10 @@ impl<'tcx> Stable<'tcx> for ty::TermKind<'tcx> { impl<'tcx> Stable<'tcx> for ty::ExistentialProjection<'tcx> { type T = stable_mir::ty::ExistentialProjection; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let ty::ExistentialProjection { def_id, args, term, .. } = self; stable_mir::ty::ExistentialProjection { @@ -138,10 +138,10 @@ impl<'tcx> Stable<'tcx> for ty::ExistentialProjection<'tcx> { impl<'tcx> Stable<'tcx> for ty::adjustment::PointerCoercion { type T = stable_mir::mir::PointerCoercion; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::ty::adjustment::PointerCoercion; match self { @@ -162,7 +162,7 @@ impl<'tcx> Stable<'tcx> for ty::adjustment::PointerCoercion { impl<'tcx> Stable<'tcx> for ty::UserTypeAnnotationIndex { type T = usize; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { self.as_usize() } } @@ -170,7 +170,7 @@ impl<'tcx> Stable<'tcx> for ty::UserTypeAnnotationIndex { impl<'tcx> Stable<'tcx> for ty::AdtKind { type T = AdtKind; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { ty::AdtKind::Struct => AdtKind::Struct, ty::AdtKind::Union => AdtKind::Union, @@ -182,10 +182,10 @@ impl<'tcx> Stable<'tcx> for ty::AdtKind { impl<'tcx> Stable<'tcx> for ty::FieldDef { type T = stable_mir::ty::FieldDef; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { stable_mir::ty::FieldDef { def: tables.create_def_id(self.did), @@ -196,10 +196,10 @@ impl<'tcx> Stable<'tcx> for ty::FieldDef { impl<'tcx> Stable<'tcx> for ty::GenericArgs<'tcx> { type T = stable_mir::ty::GenericArgs; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { GenericArgs(self.iter().map(|arg| arg.kind().stable(tables, cx)).collect()) } @@ -208,10 +208,10 @@ impl<'tcx> Stable<'tcx> for ty::GenericArgs<'tcx> { impl<'tcx> Stable<'tcx> for ty::GenericArgKind<'tcx> { type T = stable_mir::ty::GenericArgKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::GenericArgKind; match self { @@ -230,10 +230,10 @@ where { type T = stable_mir::ty::Binder; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::Binder; @@ -254,10 +254,10 @@ where { type T = stable_mir::ty::EarlyBinder; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::EarlyBinder; @@ -267,10 +267,10 @@ where impl<'tcx> Stable<'tcx> for ty::FnSig<'tcx> { type T = stable_mir::ty::FnSig; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::FnSig; @@ -290,11 +290,7 @@ impl<'tcx> Stable<'tcx> for ty::FnSig<'tcx> { impl<'tcx> Stable<'tcx> for ty::BoundTyKind { type T = stable_mir::ty::BoundTyKind; - fn stable( - &self, - tables: &mut Tables<'tcx, BridgeTys>, - _: &SmirCtxt<'tcx, BridgeTys>, - ) -> Self::T { + fn stable<'cx>(&self, tables: &mut Tables<'cx, BridgeTys>, _: &SmirCtxt<'cx, BridgeTys>) -> Self::T { use stable_mir::ty::BoundTyKind; match self { @@ -309,11 +305,7 @@ impl<'tcx> Stable<'tcx> for ty::BoundTyKind { impl<'tcx> Stable<'tcx> for ty::BoundRegionKind { type T = stable_mir::ty::BoundRegionKind; - fn stable( - &self, - tables: &mut Tables<'tcx, BridgeTys>, - _: &SmirCtxt<'tcx, BridgeTys>, - ) -> Self::T { + fn stable<'cx>(&self, tables: &mut Tables<'cx, BridgeTys>, _: &SmirCtxt<'cx, BridgeTys>) -> Self::T { use stable_mir::ty::BoundRegionKind; match self { @@ -329,10 +321,10 @@ impl<'tcx> Stable<'tcx> for ty::BoundRegionKind { impl<'tcx> Stable<'tcx> for ty::BoundVariableKind { type T = stable_mir::ty::BoundVariableKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::BoundVariableKind; @@ -351,7 +343,7 @@ impl<'tcx> Stable<'tcx> for ty::BoundVariableKind { impl<'tcx> Stable<'tcx> for ty::IntTy { type T = IntTy; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { ty::IntTy::Isize => IntTy::Isize, ty::IntTy::I8 => IntTy::I8, @@ -366,7 +358,7 @@ impl<'tcx> Stable<'tcx> for ty::IntTy { impl<'tcx> Stable<'tcx> for ty::UintTy { type T = UintTy; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { ty::UintTy::Usize => UintTy::Usize, ty::UintTy::U8 => UintTy::U8, @@ -381,7 +373,7 @@ impl<'tcx> Stable<'tcx> for ty::UintTy { impl<'tcx> Stable<'tcx> for ty::FloatTy { type T = FloatTy; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { ty::FloatTy::F16 => FloatTy::F16, ty::FloatTy::F32 => FloatTy::F32, @@ -393,10 +385,10 @@ impl<'tcx> Stable<'tcx> for ty::FloatTy { impl<'tcx> Stable<'tcx> for Ty<'tcx> { type T = stable_mir::ty::Ty; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { tables.intern_ty(cx.lift(*self).unwrap()) } @@ -404,10 +396,10 @@ impl<'tcx> Stable<'tcx> for Ty<'tcx> { impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> { type T = stable_mir::ty::TyKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match self { ty::Bool => TyKind::RigidTy(RigidTy::Bool), @@ -490,10 +482,10 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> { impl<'tcx> Stable<'tcx> for ty::Pattern<'tcx> { type T = stable_mir::ty::Pattern; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { match **self { ty::PatternKind::Range { start, end } => stable_mir::ty::Pattern::Range { @@ -510,10 +502,10 @@ impl<'tcx> Stable<'tcx> for ty::Pattern<'tcx> { impl<'tcx> Stable<'tcx> for ty::Const<'tcx> { type T = stable_mir::ty::TyConst; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let ct = cx.lift(*self).unwrap(); let kind = match ct.kind() { @@ -548,7 +540,7 @@ impl<'tcx> Stable<'tcx> for ty::Const<'tcx> { impl<'tcx> Stable<'tcx> for ty::ParamConst { type T = stable_mir::ty::ParamConst; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use stable_mir::ty::ParamConst; ParamConst { index: self.index, name: self.name.to_string() } } @@ -556,7 +548,7 @@ impl<'tcx> Stable<'tcx> for ty::ParamConst { impl<'tcx> Stable<'tcx> for ty::ParamTy { type T = stable_mir::ty::ParamTy; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use stable_mir::ty::ParamTy; ParamTy { index: self.index, name: self.name.to_string() } } @@ -564,10 +556,10 @@ impl<'tcx> Stable<'tcx> for ty::ParamTy { impl<'tcx> Stable<'tcx> for ty::BoundTy { type T = stable_mir::ty::BoundTy; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::BoundTy; BoundTy { var: self.var.as_usize(), kind: self.kind.stable(tables, cx) } @@ -576,7 +568,7 @@ impl<'tcx> Stable<'tcx> for ty::BoundTy { impl<'tcx> Stable<'tcx> for ty::trait_def::TraitSpecializationKind { type T = stable_mir::ty::TraitSpecializationKind; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use stable_mir::ty::TraitSpecializationKind; match self { @@ -591,10 +583,10 @@ impl<'tcx> Stable<'tcx> for ty::trait_def::TraitSpecializationKind { impl<'tcx> Stable<'tcx> for ty::TraitDef { type T = stable_mir::ty::TraitDecl; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::opaque; use stable_mir::ty::TraitDecl; @@ -621,10 +613,10 @@ impl<'tcx> Stable<'tcx> for ty::TraitDef { impl<'tcx> Stable<'tcx> for ty::TraitRef<'tcx> { type T = stable_mir::ty::TraitRef; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::TraitRef; @@ -635,10 +627,10 @@ impl<'tcx> Stable<'tcx> for ty::TraitRef<'tcx> { impl<'tcx> Stable<'tcx> for ty::Generics { type T = stable_mir::ty::Generics; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::Generics; @@ -663,7 +655,7 @@ impl<'tcx> Stable<'tcx> for ty::Generics { impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDefKind { type T = stable_mir::ty::GenericParamDefKind; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use stable_mir::ty::GenericParamDefKind; match self { ty::GenericParamDefKind::Lifetime => GenericParamDefKind::Lifetime, @@ -680,10 +672,10 @@ impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDefKind { impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDef { type T = stable_mir::ty::GenericParamDef; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { GenericParamDef { name: self.name.to_string(), @@ -698,10 +690,10 @@ impl<'tcx> Stable<'tcx> for rustc_middle::ty::GenericParamDef { impl<'tcx> Stable<'tcx> for ty::PredicateKind<'tcx> { type T = stable_mir::ty::PredicateKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::ty::PredicateKind; match self { @@ -737,10 +729,10 @@ impl<'tcx> Stable<'tcx> for ty::PredicateKind<'tcx> { impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> { type T = stable_mir::ty::ClauseKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use rustc_middle::ty::ClauseKind; match *self { @@ -780,7 +772,7 @@ impl<'tcx> Stable<'tcx> for ty::ClauseKind<'tcx> { impl<'tcx> Stable<'tcx> for ty::ClosureKind { type T = stable_mir::ty::ClosureKind; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::ty::ClosureKind::*; match self { Fn => stable_mir::ty::ClosureKind::Fn, @@ -793,10 +785,10 @@ impl<'tcx> Stable<'tcx> for ty::ClosureKind { impl<'tcx> Stable<'tcx> for ty::SubtypePredicate<'tcx> { type T = stable_mir::ty::SubtypePredicate; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let ty::SubtypePredicate { a, b, a_is_expected: _ } = self; stable_mir::ty::SubtypePredicate { a: a.stable(tables, cx), b: b.stable(tables, cx) } @@ -806,10 +798,10 @@ impl<'tcx> Stable<'tcx> for ty::SubtypePredicate<'tcx> { impl<'tcx> Stable<'tcx> for ty::CoercePredicate<'tcx> { type T = stable_mir::ty::CoercePredicate; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let ty::CoercePredicate { a, b } = self; stable_mir::ty::CoercePredicate { a: a.stable(tables, cx), b: b.stable(tables, cx) } @@ -819,7 +811,7 @@ impl<'tcx> Stable<'tcx> for ty::CoercePredicate<'tcx> { impl<'tcx> Stable<'tcx> for ty::AliasRelationDirection { type T = stable_mir::ty::AliasRelationDirection; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::ty::AliasRelationDirection::*; match self { Equate => stable_mir::ty::AliasRelationDirection::Equate, @@ -831,10 +823,10 @@ impl<'tcx> Stable<'tcx> for ty::AliasRelationDirection { impl<'tcx> Stable<'tcx> for ty::TraitPredicate<'tcx> { type T = stable_mir::ty::TraitPredicate; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let ty::TraitPredicate { trait_ref, polarity } = self; stable_mir::ty::TraitPredicate { @@ -850,10 +842,10 @@ where { type T = stable_mir::ty::OutlivesPredicate; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let ty::OutlivesPredicate(a, b) = self; stable_mir::ty::OutlivesPredicate(a.stable(tables, cx), b.stable(tables, cx)) @@ -863,10 +855,10 @@ where impl<'tcx> Stable<'tcx> for ty::ProjectionPredicate<'tcx> { type T = stable_mir::ty::ProjectionPredicate; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let ty::ProjectionPredicate { projection_term, term } = self; stable_mir::ty::ProjectionPredicate { @@ -879,7 +871,7 @@ impl<'tcx> Stable<'tcx> for ty::ProjectionPredicate<'tcx> { impl<'tcx> Stable<'tcx> for ty::ImplPolarity { type T = stable_mir::ty::ImplPolarity; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::ty::ImplPolarity::*; match self { Positive => stable_mir::ty::ImplPolarity::Positive, @@ -892,7 +884,7 @@ impl<'tcx> Stable<'tcx> for ty::ImplPolarity { impl<'tcx> Stable<'tcx> for ty::PredicatePolarity { type T = stable_mir::ty::PredicatePolarity; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_middle::ty::PredicatePolarity::*; match self { Positive => stable_mir::ty::PredicatePolarity::Positive, @@ -904,10 +896,10 @@ impl<'tcx> Stable<'tcx> for ty::PredicatePolarity { impl<'tcx> Stable<'tcx> for ty::Region<'tcx> { type T = stable_mir::ty::Region; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { Region { kind: self.kind().stable(tables, cx) } } @@ -916,10 +908,10 @@ impl<'tcx> Stable<'tcx> for ty::Region<'tcx> { impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> { type T = stable_mir::ty::RegionKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::{BoundRegion, EarlyParamRegion, RegionKind}; match self { @@ -953,10 +945,10 @@ impl<'tcx> Stable<'tcx> for ty::RegionKind<'tcx> { impl<'tcx> Stable<'tcx> for ty::Instance<'tcx> { type T = stable_mir::mir::mono::Instance; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { let def = tables.instance_def(cx.lift(*self).unwrap()); let kind = match self.def { @@ -986,7 +978,7 @@ impl<'tcx> Stable<'tcx> for ty::Instance<'tcx> { impl<'tcx> Stable<'tcx> for ty::Variance { type T = stable_mir::mir::Variance; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { ty::Bivariant => stable_mir::mir::Variance::Bivariant, ty::Contravariant => stable_mir::mir::Variance::Contravariant, @@ -999,7 +991,7 @@ impl<'tcx> Stable<'tcx> for ty::Variance { impl<'tcx> Stable<'tcx> for ty::Movability { type T = stable_mir::ty::Movability; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { match self { ty::Movability::Static => stable_mir::ty::Movability::Static, ty::Movability::Movable => stable_mir::ty::Movability::Movable, @@ -1010,7 +1002,7 @@ impl<'tcx> Stable<'tcx> for ty::Movability { impl<'tcx> Stable<'tcx> for rustc_abi::ExternAbi { type T = stable_mir::ty::Abi; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use rustc_abi::ExternAbi; use stable_mir::ty::Abi; match *self { @@ -1047,10 +1039,10 @@ impl<'tcx> Stable<'tcx> for rustc_abi::ExternAbi { impl<'tcx> Stable<'tcx> for rustc_session::cstore::ForeignModule { type T = stable_mir::ty::ForeignModule; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { stable_mir::ty::ForeignModule { def_id: tables.foreign_module_def(self.def_id), @@ -1062,10 +1054,10 @@ impl<'tcx> Stable<'tcx> for rustc_session::cstore::ForeignModule { impl<'tcx> Stable<'tcx> for ty::AssocKind { type T = stable_mir::ty::AssocKind; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { use stable_mir::ty::{AssocKind, AssocTypeData}; match *self { @@ -1088,7 +1080,7 @@ impl<'tcx> Stable<'tcx> for ty::AssocKind { impl<'tcx> Stable<'tcx> for ty::AssocItemContainer { type T = stable_mir::ty::AssocItemContainer; - fn stable(&self, _: &mut Tables<'tcx, BridgeTys>, _: &SmirCtxt<'tcx, BridgeTys>) -> Self::T { + fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &SmirCtxt<'_, BridgeTys>) -> Self::T { use stable_mir::ty::AssocItemContainer; match self { ty::AssocItemContainer::Trait => AssocItemContainer::Trait, @@ -1100,10 +1092,10 @@ impl<'tcx> Stable<'tcx> for ty::AssocItemContainer { impl<'tcx> Stable<'tcx> for ty::AssocItem { type T = stable_mir::ty::AssocItem; - fn stable( + fn stable<'cx>( &self, - tables: &mut Tables<'tcx, BridgeTys>, - cx: &SmirCtxt<'tcx, BridgeTys>, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { stable_mir::ty::AssocItem { def_id: tables.assoc_def(self.def_id), @@ -1117,11 +1109,7 @@ impl<'tcx> Stable<'tcx> for ty::AssocItem { impl<'tcx> Stable<'tcx> for ty::ImplTraitInTraitData { type T = stable_mir::ty::ImplTraitInTraitData; - fn stable( - &self, - tables: &mut Tables<'tcx, BridgeTys>, - _: &SmirCtxt<'tcx, BridgeTys>, - ) -> Self::T { + fn stable<'cx>(&self, tables: &mut Tables<'cx, BridgeTys>, _: &SmirCtxt<'cx, BridgeTys>) -> Self::T { use stable_mir::ty::ImplTraitInTraitData; match self { ty::ImplTraitInTraitData::Trait { fn_def_id, opaque_def_id } => { From 903830df8bad1e1dfb4810e99502935e1136c605 Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 9 Jun 2025 08:24:25 +0000 Subject: [PATCH 16/22] cleanup: re-export `IndexedVal` and fix some nits --- compiler/rustc_smir/src/rustc_smir/bridge.rs | 56 ++++++++++--------- compiler/rustc_smir/src/stable_mir/abi.rs | 2 +- .../src/stable_mir/compiler_interface.rs | 37 ------------ .../rustc_smir/src/stable_mir/mir/alloc.rs | 5 +- .../rustc_smir/src/stable_mir/mir/mono.rs | 3 +- .../rustc_smir/src/stable_mir/mir/pretty.rs | 5 +- compiler/rustc_smir/src/stable_mir/mod.rs | 37 ++++++++++++ compiler/rustc_smir/src/stable_mir/ty.rs | 7 +-- 8 files changed, 77 insertions(+), 75 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_smir/bridge.rs b/compiler/rustc_smir/src/rustc_smir/bridge.rs index 671b0d2093781..0a1c09043ea19 100644 --- a/compiler/rustc_smir/src/rustc_smir/bridge.rs +++ b/compiler/rustc_smir/src/rustc_smir/bridge.rs @@ -1,3 +1,9 @@ +//! Defines a set of traits that is used for abstracting +//! stable_mir's components that are needed in rustc_smir. +//! +//! These traits are really useful when programming +//! in stable_mir-agnostic settings. + use std::fmt::Debug; use super::Bridge; @@ -7,7 +13,11 @@ pub trait SmirError { fn from_internal(err: T) -> Self; } -macro_rules! make_def_trait { +pub trait Prov { + fn new(aid: B::AllocId) -> Self; +} + +macro_rules! make_bridge_trait { ($name:ident) => { pub trait $name { fn new(did: B::DefId) -> Self; @@ -15,27 +25,23 @@ macro_rules! make_def_trait { }; } -make_def_trait!(CrateItem); -make_def_trait!(AdtDef); -make_def_trait!(ForeignModuleDef); -make_def_trait!(ForeignDef); -make_def_trait!(FnDef); -make_def_trait!(ClosureDef); -make_def_trait!(CoroutineDef); -make_def_trait!(CoroutineClosureDef); -make_def_trait!(AliasDef); -make_def_trait!(ParamDef); -make_def_trait!(BrNamedDef); -make_def_trait!(TraitDef); -make_def_trait!(GenericDef); -make_def_trait!(ConstDef); -make_def_trait!(ImplDef); -make_def_trait!(RegionDef); -make_def_trait!(CoroutineWitnessDef); -make_def_trait!(AssocDef); -make_def_trait!(OpaqueDef); -make_def_trait!(StaticDef); - -pub trait Prov { - fn new(aid: B::AllocId) -> Self; -} +make_bridge_trait!(CrateItem); +make_bridge_trait!(AdtDef); +make_bridge_trait!(ForeignModuleDef); +make_bridge_trait!(ForeignDef); +make_bridge_trait!(FnDef); +make_bridge_trait!(ClosureDef); +make_bridge_trait!(CoroutineDef); +make_bridge_trait!(CoroutineClosureDef); +make_bridge_trait!(AliasDef); +make_bridge_trait!(ParamDef); +make_bridge_trait!(BrNamedDef); +make_bridge_trait!(TraitDef); +make_bridge_trait!(GenericDef); +make_bridge_trait!(ConstDef); +make_bridge_trait!(ImplDef); +make_bridge_trait!(RegionDef); +make_bridge_trait!(CoroutineWitnessDef); +make_bridge_trait!(AssocDef); +make_bridge_trait!(OpaqueDef); +make_bridge_trait!(StaticDef); diff --git a/compiler/rustc_smir/src/stable_mir/abi.rs b/compiler/rustc_smir/src/stable_mir/abi.rs index 3c8bdb243d4c2..369d08e444ec5 100644 --- a/compiler/rustc_smir/src/stable_mir/abi.rs +++ b/compiler/rustc_smir/src/stable_mir/abi.rs @@ -119,7 +119,7 @@ impl Layout { } } -impl crate::rustc_smir::IndexedVal for Layout { +impl stable_mir::IndexedVal for Layout { fn to_val(index: usize) -> Self { Layout(index) } diff --git a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs index 4f3deb00eb090..e59bf0ad9cd03 100644 --- a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs +++ b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs @@ -65,43 +65,6 @@ impl Bridge for BridgeTys { type StaticDef = stable_mir::mir::mono::StaticDef; } -macro_rules! bridge_def { - ($name: ident, $ty: ty) => { - impl rustc_smir::bridge::$name for $ty { - fn new(def: stable_mir::DefId) -> Self { - Self(def) - } - } - }; -} - -bridge_def!(CrateItem, stable_mir::CrateItem); -bridge_def!(AdtDef, stable_mir::ty::AdtDef); -bridge_def!(ForeignModuleDef, stable_mir::ty::ForeignModuleDef); -bridge_def!(ForeignDef, stable_mir::ty::ForeignDef); -bridge_def!(FnDef, stable_mir::ty::FnDef); -bridge_def!(ClosureDef, stable_mir::ty::ClosureDef); -bridge_def!(CoroutineDef, stable_mir::ty::CoroutineDef); -bridge_def!(CoroutineClosureDef, stable_mir::ty::CoroutineClosureDef); -bridge_def!(AliasDef, stable_mir::ty::AliasDef); -bridge_def!(ParamDef, stable_mir::ty::ParamDef); -bridge_def!(BrNamedDef, stable_mir::ty::BrNamedDef); -bridge_def!(TraitDef, stable_mir::ty::TraitDef); -bridge_def!(GenericDef, stable_mir::ty::GenericDef); -bridge_def!(ConstDef, stable_mir::ty::ConstDef); -bridge_def!(ImplDef, stable_mir::ty::ImplDef); -bridge_def!(RegionDef, stable_mir::ty::RegionDef); -bridge_def!(CoroutineWitnessDef, stable_mir::ty::CoroutineWitnessDef); -bridge_def!(AssocDef, stable_mir::ty::AssocDef); -bridge_def!(OpaqueDef, stable_mir::ty::OpaqueDef); -bridge_def!(StaticDef, stable_mir::mir::mono::StaticDef); - -impl rustc_smir::bridge::Prov for stable_mir::ty::Prov { - fn new(aid: stable_mir::mir::alloc::AllocId) -> Self { - Self(aid) - } -} - /// Stable public API for querying compiler information. /// /// All queries are delegated to [`crate::rustc_smir::context::SmirCtxt`] that provides diff --git a/compiler/rustc_smir/src/stable_mir/mir/alloc.rs b/compiler/rustc_smir/src/stable_mir/mir/alloc.rs index 325f26da8bbf3..26f30898a9cc0 100644 --- a/compiler/rustc_smir/src/stable_mir/mir/alloc.rs +++ b/compiler/rustc_smir/src/stable_mir/mir/alloc.rs @@ -2,14 +2,13 @@ use std::io::Read; -use rustc_smir::IndexedVal; use serde::Serialize; use stable_mir::mir::mono::{Instance, StaticDef}; use stable_mir::target::{Endian, MachineInfo}; use stable_mir::ty::{Allocation, Binder, ExistentialTraitRef, Ty}; -use stable_mir::{Error, with}; +use stable_mir::{Error, IndexedVal, with}; -use crate::{rustc_smir, stable_mir}; +use crate::stable_mir; /// An allocation in the SMIR global memory can be either a function pointer, /// a static, or a "real" allocation with some data in it. diff --git a/compiler/rustc_smir/src/stable_mir/mir/mono.rs b/compiler/rustc_smir/src/stable_mir/mir/mono.rs index e84852bf5267a..5f177416714eb 100644 --- a/compiler/rustc_smir/src/stable_mir/mir/mono.rs +++ b/compiler/rustc_smir/src/stable_mir/mir/mono.rs @@ -1,14 +1,13 @@ use std::fmt::{Debug, Formatter}; use std::io; -use rustc_smir::IndexedVal; use rustc_smir::bridge::SmirError; use serde::Serialize; use stable_mir::abi::FnAbi; use stable_mir::crate_def::CrateDef; use stable_mir::mir::Body; use stable_mir::ty::{Allocation, ClosureDef, ClosureKind, FnDef, GenericArgs, Ty}; -use stable_mir::{CrateItem, DefId, Error, ItemKind, Opaque, Symbol, with}; +use stable_mir::{CrateItem, DefId, Error, IndexedVal, ItemKind, Opaque, Symbol, with}; use crate::{rustc_smir, stable_mir}; diff --git a/compiler/rustc_smir/src/stable_mir/mir/pretty.rs b/compiler/rustc_smir/src/stable_mir/mir/pretty.rs index b44afb1dc688b..bf0bf3cff6fd4 100644 --- a/compiler/rustc_smir/src/stable_mir/mir/pretty.rs +++ b/compiler/rustc_smir/src/stable_mir/mir/pretty.rs @@ -4,15 +4,14 @@ use std::io::Write; use std::{fmt, io, iter}; use fmt::{Display, Formatter}; -use rustc_smir::IndexedVal; use stable_mir::mir::{ Operand, Place, RawPtrKind, Rvalue, StatementKind, UnwindAction, VarDebugInfoContents, }; use stable_mir::ty::{AdtKind, AssocKind, MirConst, Ty, TyConst}; -use stable_mir::{Body, CrateDef, Mutability, with}; +use stable_mir::{Body, CrateDef, IndexedVal, Mutability, with}; use super::{AggregateKind, AssertMessage, BinOp, BorrowKind, FakeBorrowKind, TerminatorKind}; -use crate::{rustc_smir, stable_mir}; +use crate::stable_mir; impl Display for Ty { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { diff --git a/compiler/rustc_smir/src/stable_mir/mod.rs b/compiler/rustc_smir/src/stable_mir/mod.rs index abb5e843e7718..65b016ab13711 100644 --- a/compiler/rustc_smir/src/stable_mir/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/mod.rs @@ -240,3 +240,40 @@ impl std::fmt::Debug for Opaque { pub fn opaque(value: &T) -> Opaque { Opaque(format!("{value:?}")) } + +macro_rules! bridge_impl { + ($name: ident, $ty: ty) => { + impl rustc_smir::bridge::$name for $ty { + fn new(def: stable_mir::DefId) -> Self { + Self(def) + } + } + }; +} + +bridge_impl!(CrateItem, stable_mir::CrateItem); +bridge_impl!(AdtDef, stable_mir::ty::AdtDef); +bridge_impl!(ForeignModuleDef, stable_mir::ty::ForeignModuleDef); +bridge_impl!(ForeignDef, stable_mir::ty::ForeignDef); +bridge_impl!(FnDef, stable_mir::ty::FnDef); +bridge_impl!(ClosureDef, stable_mir::ty::ClosureDef); +bridge_impl!(CoroutineDef, stable_mir::ty::CoroutineDef); +bridge_impl!(CoroutineClosureDef, stable_mir::ty::CoroutineClosureDef); +bridge_impl!(AliasDef, stable_mir::ty::AliasDef); +bridge_impl!(ParamDef, stable_mir::ty::ParamDef); +bridge_impl!(BrNamedDef, stable_mir::ty::BrNamedDef); +bridge_impl!(TraitDef, stable_mir::ty::TraitDef); +bridge_impl!(GenericDef, stable_mir::ty::GenericDef); +bridge_impl!(ConstDef, stable_mir::ty::ConstDef); +bridge_impl!(ImplDef, stable_mir::ty::ImplDef); +bridge_impl!(RegionDef, stable_mir::ty::RegionDef); +bridge_impl!(CoroutineWitnessDef, stable_mir::ty::CoroutineWitnessDef); +bridge_impl!(AssocDef, stable_mir::ty::AssocDef); +bridge_impl!(OpaqueDef, stable_mir::ty::OpaqueDef); +bridge_impl!(StaticDef, stable_mir::mir::mono::StaticDef); + +impl rustc_smir::bridge::Prov for stable_mir::ty::Prov { + fn new(aid: stable_mir::mir::alloc::AllocId) -> Self { + Self(aid) + } +} diff --git a/compiler/rustc_smir/src/stable_mir/ty.rs b/compiler/rustc_smir/src/stable_mir/ty.rs index 5a9473df8e392..8bde32bbbf549 100644 --- a/compiler/rustc_smir/src/stable_mir/ty.rs +++ b/compiler/rustc_smir/src/stable_mir/ty.rs @@ -1,19 +1,18 @@ use std::fmt::{self, Debug, Display, Formatter}; use std::ops::Range; -use rustc_smir::IndexedVal; use serde::Serialize; use stable_mir::abi::{FnAbi, Layout}; use stable_mir::crate_def::{CrateDef, CrateDefItems, CrateDefType}; use stable_mir::mir::alloc::{AllocId, read_target_int, read_target_uint}; use stable_mir::mir::mono::StaticDef; use stable_mir::target::MachineInfo; -use stable_mir::{Filename, Opaque}; +use stable_mir::{Filename, IndexedVal, Opaque}; use super::abi::ReprOptions; use super::mir::{Body, Mutability, Safety}; use super::{DefId, Error, Symbol, with}; -use crate::{rustc_smir, stable_mir}; +use crate::stable_mir; #[derive(Copy, Clone, Eq, PartialEq, Hash, Serialize)] pub struct Ty(usize); @@ -1560,7 +1559,7 @@ pub enum PredicatePolarity { macro_rules! index_impl { ($name:ident) => { - impl crate::rustc_smir::IndexedVal for $name { + impl stable_mir::IndexedVal for $name { fn to_val(index: usize) -> Self { $name(index) } From 75a9d7f7b3d7627861bee7634105a16e8dd4995d Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 9 Jun 2025 08:24:59 +0000 Subject: [PATCH 17/22] test: fix the usage of `rustc_internal::internal()` --- tests/ui-fulldeps/stable-mir/smir_internal.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tests/ui-fulldeps/stable-mir/smir_internal.rs b/tests/ui-fulldeps/stable-mir/smir_internal.rs index 478a5e3f102d2..0519b9de68050 100644 --- a/tests/ui-fulldeps/stable-mir/smir_internal.rs +++ b/tests/ui-fulldeps/stable-mir/smir_internal.rs @@ -17,17 +17,18 @@ extern crate rustc_interface; extern crate rustc_middle; extern crate stable_mir; +use rustc_middle::ty::TyCtxt; use rustc_smir::rustc_internal; use std::io::Write; use std::ops::ControlFlow; const CRATE_NAME: &str = "input"; -fn test_translation() -> ControlFlow<()> { +fn test_translation(tcx: TyCtxt<'_>) -> ControlFlow<()> { let main_fn = stable_mir::entry_fn().unwrap(); let body = main_fn.expect_body(); 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()); ControlFlow::Continue(()) } @@ -45,7 +46,7 @@ fn main() { CRATE_NAME.to_string(), path.to_string(), ]; - run!(args, test_translation).unwrap(); + run_with_tcx!(args, test_translation).unwrap(); } fn generate_input(path: &str) -> std::io::Result<()> { From a071edf7de818ea159c10b63a2adcd5f17f39444 Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 9 Jun 2025 08:26:12 +0000 Subject: [PATCH 18/22] refactor: avoid calling internal functions in `predicates_of()` and `explicit_predicates_of()` --- .../src/rustc_smir/context/impls.rs | 34 +++++++++++++++---- .../src/stable_mir/compiler_interface.rs | 23 ++++--------- 2 files changed, 33 insertions(+), 24 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_smir/context/impls.rs b/compiler/rustc_smir/src/rustc_smir/context/impls.rs index 4ca785d1e9635..0487977517959 100644 --- a/compiler/rustc_smir/src/rustc_smir/context/impls.rs +++ b/compiler/rustc_smir/src/rustc_smir/context/impls.rs @@ -15,9 +15,9 @@ use rustc_middle::mir::{BinOp, Body, Const as MirConst, ConstValue, UnOp}; use rustc_middle::ty::layout::{FnAbiOf, LayoutOf}; use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths}; use rustc_middle::ty::{ - AdtDef, AdtKind, AssocItem, ClosureKind, GenericArgsRef, GenericPredicates, Instance, - InstanceKind, IntrinsicDef, List, PolyFnSig, ScalarInt, TraitDef, Ty, TyCtxt, TyKind, - TypeVisitableExt, UintTy, ValTree, VariantDef, + AdtDef, AdtKind, AssocItem, ClosureKind, GenericArgsRef, Instance, InstanceKind, IntrinsicDef, + List, PolyFnSig, ScalarInt, TraitDef, Ty, TyCtxt, TyKind, TypeVisitableExt, UintTy, ValTree, + VariantDef, }; use rustc_middle::{mir, ty}; use rustc_session::cstore::ForeignModule; @@ -197,12 +197,32 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { self.tcx.generics_of(def_id) } - pub fn predicates_of(&self, def_id: DefId) -> GenericPredicates<'tcx> { - self.tcx.predicates_of(def_id) + pub fn predicates_of( + &self, + def_id: DefId, + ) -> (Option, Vec<(ty::PredicateKind<'tcx>, Span)>) { + let ty::GenericPredicates { parent, predicates } = self.tcx.predicates_of(def_id); + ( + parent, + predicates + .iter() + .map(|(clause, span)| (clause.as_predicate().kind().skip_binder(), *span)) + .collect(), + ) } - pub fn explicit_predicates_of(&self, def_id: DefId) -> GenericPredicates<'tcx> { - self.tcx.explicit_predicates_of(def_id) + pub fn explicit_predicates_of( + &self, + def_id: DefId, + ) -> (Option, Vec<(ty::PredicateKind<'tcx>, Span)>) { + let ty::GenericPredicates { parent, predicates } = self.tcx.explicit_predicates_of(def_id); + ( + parent, + predicates + .iter() + .map(|(clause, span)| (clause.as_predicate().kind().skip_binder(), *span)) + .collect(), + ) } pub fn crate_name(&self, crate_num: CrateNum) -> String { diff --git a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs index e59bf0ad9cd03..bc7d0c6eabe45 100644 --- a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs +++ b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs @@ -423,17 +423,12 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); let did = tables[def_id]; - let rustc_middle::ty::GenericPredicates { parent, predicates } = cx.predicates_of(did); + let (parent, kinds) = cx.predicates_of(did); stable_mir::ty::GenericPredicates { parent: parent.map(|did| tables.trait_def(did)), - predicates: predicates + predicates: kinds .iter() - .map(|(clause, span)| { - ( - clause.as_predicate().kind().skip_binder().stable(&mut *tables, cx), - span.stable(&mut *tables, cx), - ) - }) + .map(|(kind, span)| (kind.stable(&mut *tables, cx), span.stable(&mut *tables, cx))) .collect(), } } @@ -442,18 +437,12 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { let mut tables = self.tables.borrow_mut(); let cx = &*self.cx.borrow(); let did = tables[def_id]; - let rustc_middle::ty::GenericPredicates { parent, predicates } = - cx.explicit_predicates_of(did); + let (parent, kinds) = cx.explicit_predicates_of(did); stable_mir::ty::GenericPredicates { parent: parent.map(|did| tables.trait_def(did)), - predicates: predicates + predicates: kinds .iter() - .map(|(clause, span)| { - ( - clause.as_predicate().kind().skip_binder().stable(&mut *tables, cx), - span.stable(&mut *tables, cx), - ) - }) + .map(|(kind, span)| (kind.stable(&mut *tables, cx), span.stable(&mut *tables, cx))) .collect(), } } From f199fda7686de6c33960cb212bb0ea37735a47e4 Mon Sep 17 00:00:00 2001 From: Makai Date: Mon, 9 Jun 2025 08:28:57 +0000 Subject: [PATCH 19/22] cleanup: fmt --- .../stable_mir/unstable/convert/internal.rs | 15 ++++++++------ .../src/stable_mir/unstable/convert/mod.rs | 6 +----- .../stable_mir/unstable/convert/stable/abi.rs | 4 ++-- .../stable_mir/unstable/convert/stable/mir.rs | 8 ++++++-- .../stable_mir/unstable/convert/stable/mod.rs | 6 +++++- .../stable_mir/unstable/convert/stable/ty.rs | 20 +++++++++++++++---- .../rustc_smir/src/stable_mir/unstable/mod.rs | 20 +++++++++---------- 7 files changed, 49 insertions(+), 30 deletions(-) diff --git a/compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs index bd7aa6d09d1f0..f33edcf8c4260 100644 --- a/compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/internal.rs @@ -10,7 +10,6 @@ use rustc_smir::Tables; use rustc_span::Symbol; use stable_mir::abi::Layout; use stable_mir::compiler_interface::BridgeTys; -use stable_mir::unstable::{RustcInternal, InternalCx}; use stable_mir::mir::alloc::AllocId; use stable_mir::mir::mono::{Instance, MonoItem, StaticDef}; use stable_mir::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp}; @@ -20,11 +19,11 @@ use stable_mir::ty::{ GenericArgKind, GenericArgs, IntTy, MirConst, Movability, Pattern, Region, RigidTy, Span, TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx, }; +use stable_mir::unstable::{InternalCx, RustcInternal}; use stable_mir::{CrateItem, CrateNum, DefId, IndexedVal}; use crate::{rustc_smir, stable_mir}; - impl RustcInternal for CrateItem { type T<'tcx> = rustc_span::def_id::DefId; fn internal<'tcx>( @@ -447,9 +446,10 @@ impl RustcInternal for BoundVariableKind { match self { BoundVariableKind::Ty(kind) => rustc_ty::BoundVariableKind::Ty(match kind { BoundTyKind::Anon => rustc_ty::BoundTyKind::Anon, - BoundTyKind::Param(def, symbol) => { - rustc_ty::BoundTyKind::Param(def.0.internal(tables, tcx), Symbol::intern(symbol)) - } + BoundTyKind::Param(def, symbol) => rustc_ty::BoundTyKind::Param( + def.0.internal(tables, tcx), + Symbol::intern(symbol), + ), }), BoundVariableKind::Region(kind) => rustc_ty::BoundVariableKind::Region(match kind { BoundRegionKind::BrAnon => rustc_ty::BoundRegionKind::Anon, @@ -542,7 +542,10 @@ impl RustcInternal for ExistentialTraitRef { tcx: impl InternalCx<'tcx>, ) -> Self::T<'tcx> { use rustc_smir::context::SmirExistentialTraitRef; - tcx.new_from_args(self.def_id.0.internal(tables, tcx), self.generic_args.internal(tables, tcx)) + tcx.new_from_args( + self.def_id.0.internal(tables, tcx), + self.generic_args.internal(tables, tcx), + ) } } diff --git a/compiler/rustc_smir/src/stable_mir/unstable/convert/mod.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/mod.rs index 4c8a776d52978..6e1b85671f843 100644 --- a/compiler/rustc_smir/src/stable_mir/unstable/convert/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/mod.rs @@ -8,16 +8,12 @@ use std::ops::RangeInclusive; - use rustc_smir::Tables; use rustc_smir::context::SmirCtxt; - use stable_mir::compiler_interface::BridgeTys; -use crate::{rustc_smir, stable_mir}; - use super::Stable; - +use crate::{rustc_smir, stable_mir}; mod internal; mod stable; diff --git a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs index 02339730b27d3..0d8ecf4df2af8 100644 --- a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs @@ -13,9 +13,9 @@ use stable_mir::abi::{ TagEncoding, TyAndLayout, ValueAbi, VariantsShape, WrappingRange, }; use stable_mir::compiler_interface::BridgeTys; -use stable_mir::unstable::Stable; use stable_mir::target::MachineSize as Size; use stable_mir::ty::{Align, VariantIdx}; +use stable_mir::unstable::Stable; use stable_mir::{IndexedVal, opaque}; use crate::{rustc_smir, stable_mir}; @@ -212,7 +212,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Variants Stable<'tcx> for mir::interpret::Allocation { impl<'tcx> Stable<'tcx> for mir::interpret::AllocId { type T = stable_mir::mir::alloc::AllocId; - fn stable<'cx>(&self, tables: &mut Tables<'cx, BridgeTys>, _: &SmirCtxt<'cx, BridgeTys>) -> Self::T { + fn stable<'cx>( + &self, + tables: &mut Tables<'cx, BridgeTys>, + _: &SmirCtxt<'cx, BridgeTys>, + ) -> Self::T { tables.create_alloc_id(*self) } } diff --git a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/mod.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/mod.rs index bd6542394dc8c..799917c6e171b 100644 --- a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/mod.rs @@ -86,7 +86,11 @@ impl<'tcx> Stable<'tcx> for rustc_span::Symbol { impl<'tcx> Stable<'tcx> for rustc_span::Span { type T = stable_mir::ty::Span; - fn stable<'cx>(&self, tables: &mut Tables<'cx, BridgeTys>, _: &SmirCtxt<'cx, BridgeTys>) -> Self::T { + fn stable<'cx>( + &self, + tables: &mut Tables<'cx, BridgeTys>, + _: &SmirCtxt<'cx, BridgeTys>, + ) -> Self::T { tables.create_span(*self) } } diff --git a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs index c05bcb993b1cc..302f05932c194 100644 --- a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs @@ -6,10 +6,10 @@ use rustc_smir::Tables; use rustc_smir::context::SmirCtxt; use stable_mir::alloc; use stable_mir::compiler_interface::BridgeTys; -use stable_mir::unstable::Stable; use stable_mir::ty::{ AdtKind, FloatTy, GenericArgs, GenericParamDef, IntTy, Region, RigidTy, TyKind, UintTy, }; +use stable_mir::unstable::Stable; use crate::{rustc_smir, stable_mir}; @@ -290,7 +290,11 @@ impl<'tcx> Stable<'tcx> for ty::FnSig<'tcx> { impl<'tcx> Stable<'tcx> for ty::BoundTyKind { type T = stable_mir::ty::BoundTyKind; - fn stable<'cx>(&self, tables: &mut Tables<'cx, BridgeTys>, _: &SmirCtxt<'cx, BridgeTys>) -> Self::T { + fn stable<'cx>( + &self, + tables: &mut Tables<'cx, BridgeTys>, + _: &SmirCtxt<'cx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::BoundTyKind; match self { @@ -305,7 +309,11 @@ impl<'tcx> Stable<'tcx> for ty::BoundTyKind { impl<'tcx> Stable<'tcx> for ty::BoundRegionKind { type T = stable_mir::ty::BoundRegionKind; - fn stable<'cx>(&self, tables: &mut Tables<'cx, BridgeTys>, _: &SmirCtxt<'cx, BridgeTys>) -> Self::T { + fn stable<'cx>( + &self, + tables: &mut Tables<'cx, BridgeTys>, + _: &SmirCtxt<'cx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::BoundRegionKind; match self { @@ -1109,7 +1117,11 @@ impl<'tcx> Stable<'tcx> for ty::AssocItem { impl<'tcx> Stable<'tcx> for ty::ImplTraitInTraitData { type T = stable_mir::ty::ImplTraitInTraitData; - fn stable<'cx>(&self, tables: &mut Tables<'cx, BridgeTys>, _: &SmirCtxt<'cx, BridgeTys>) -> Self::T { + fn stable<'cx>( + &self, + tables: &mut Tables<'cx, BridgeTys>, + _: &SmirCtxt<'cx, BridgeTys>, + ) -> Self::T { use stable_mir::ty::ImplTraitInTraitData; match self { ty::ImplTraitInTraitData::Trait { fn_def_id, opaque_def_id } => { diff --git a/compiler/rustc_smir/src/stable_mir/unstable/mod.rs b/compiler/rustc_smir/src/stable_mir/unstable/mod.rs index 6163aeb1d6ea8..4fd10509b01f3 100644 --- a/compiler/rustc_smir/src/stable_mir/unstable/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/mod.rs @@ -1,20 +1,20 @@ //! Module that collects the things that have no stability guarantees. //! -//! We want to keep StableMIR definitions and logic separate from -//! any sort of conversion and usage of internal rustc code. So we +//! We want to keep StableMIR definitions and logic separate from +//! any sort of conversion and usage of internal rustc code. So we //! restrict the usage of internal items to be inside this module. use rustc_hir::def::DefKind; use rustc_middle::ty::{List, Ty, TyCtxt}; use rustc_middle::{mir, ty}; use rustc_smir::Tables; -use rustc_smir::context::{SmirCtxt, SmirExistentialProjection, SmirExistentialTraitRef, SmirTraitRef}; - +use rustc_smir::context::{ + SmirCtxt, SmirExistentialProjection, SmirExistentialTraitRef, SmirTraitRef, +}; use stable_mir::{CtorKind, ItemKind}; -use crate::{rustc_smir, stable_mir}; - use super::compiler_interface::BridgeTys; +use crate::{rustc_smir, stable_mir}; pub(crate) mod convert; @@ -84,7 +84,7 @@ impl<'tcx> InternalCx<'tcx> for TyCtxt<'tcx> { fn lifetimes_re_erased(self) -> ty::Region<'tcx> { self.lifetimes.re_erased } - + fn mk_bound_variable_kinds_from_iter(self, iter: I) -> T::Output where I: Iterator, @@ -92,7 +92,7 @@ impl<'tcx> InternalCx<'tcx> for TyCtxt<'tcx> { { TyCtxt::mk_bound_variable_kinds_from_iter(self, iter) } - + fn mk_place_elems(self, v: &[mir::PlaceElem<'tcx>]) -> &'tcx List> { TyCtxt::mk_place_elems(self, v) } @@ -103,10 +103,10 @@ impl<'tcx> InternalCx<'tcx> for TyCtxt<'tcx> { } /// Trait that defines the methods that are fine to call from [`RustcInternal`]. -/// +/// /// This trait is only for [`RustcInternal`]. Any other other access to rustc's internals /// should go through [`crate::rustc_smir::context::SmirCtxt`]. -pub trait InternalCx<'tcx> : Copy + Clone { +pub trait InternalCx<'tcx>: Copy + Clone { fn tcx(self) -> TyCtxt<'tcx>; fn lift>>(self, value: T) -> Option; From 34a11514ffaa8c893f36f6c4c8c31c372fde1fbf Mon Sep 17 00:00:00 2001 From: Makai Date: Sat, 21 Jun 2025 10:33:02 +0000 Subject: [PATCH 20/22] cleanup: don't use rustc_type_ir directly --- .../src/rustc_smir/context/impls.rs | 21 +++++++------------ 1 file changed, 8 insertions(+), 13 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_smir/context/impls.rs b/compiler/rustc_smir/src/rustc_smir/context/impls.rs index 0487977517959..c455be95b4d9a 100644 --- a/compiler/rustc_smir/src/rustc_smir/context/impls.rs +++ b/compiler/rustc_smir/src/rustc_smir/context/impls.rs @@ -7,17 +7,15 @@ use std::iter; use rustc_abi::{Endian, Layout}; use rustc_hir::def::DefKind; use rustc_hir::{Attribute, LangItem}; -use rustc_middle::infer::canonical::ir::{ - Binder, EarlyBinder, ExistentialTraitRef, FnSig, TraitRef, -}; use rustc_middle::mir::interpret::{AllocId, ConstAllocation, ErrorHandled, GlobalAlloc, Scalar}; use rustc_middle::mir::{BinOp, Body, Const as MirConst, ConstValue, UnOp}; use rustc_middle::ty::layout::{FnAbiOf, LayoutOf}; use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths}; use rustc_middle::ty::{ - AdtDef, AdtKind, AssocItem, ClosureKind, GenericArgsRef, Instance, InstanceKind, IntrinsicDef, - List, PolyFnSig, ScalarInt, TraitDef, Ty, TyCtxt, TyKind, TypeVisitableExt, UintTy, ValTree, - VariantDef, + AdtDef, AdtKind, AssocItem, Binder, ClosureKind, CoroutineArgsExt, EarlyBinder, + ExistentialTraitRef, FnSig, GenericArgsRef, Instance, InstanceKind, IntrinsicDef, List, + PolyFnSig, ScalarInt, TraitDef, TraitRef, Ty, TyCtxt, TyKind, TypeVisitableExt, UintTy, + ValTree, VariantDef, }; use rustc_middle::{mir, ty}; use rustc_session::cstore::ForeignModule; @@ -189,7 +187,7 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { self.tcx.trait_impls_in_crate(crate_num).iter().map(|impl_def_id| *impl_def_id).collect() } - pub fn trait_impl(&self, impl_def: DefId) -> EarlyBinder, TraitRef>> { + pub fn trait_impl(&self, impl_def: DefId) -> EarlyBinder<'tcx, TraitRef<'tcx>> { self.tcx.impl_trait_ref(impl_def).unwrap() } @@ -370,7 +368,7 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { &self, def_id: DefId, args_ref: GenericArgsRef<'tcx>, - ) -> Binder, FnSig>> { + ) -> Binder<'tcx, FnSig<'tcx>> { let sig = self.tcx.fn_sig(def_id).instantiate(self.tcx, args_ref); sig } @@ -387,10 +385,7 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { } /// Retrieve the closure signature for the given generic arguments. - pub fn closure_sig( - &self, - args_ref: GenericArgsRef<'tcx>, - ) -> Binder, FnSig>> { + pub fn closure_sig(&self, args_ref: GenericArgsRef<'tcx>) -> Binder<'tcx, FnSig<'tcx>> { args_ref.as_closure().sig() } @@ -686,7 +681,7 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { pub fn vtable_allocation( &self, ty: Ty<'tcx>, - trait_ref: Option, ExistentialTraitRef>>>, + trait_ref: Option>>, ) -> AllocId { let alloc_id = self.tcx.vtable_allocation(( ty, From 3a4b906bfd3b3f29361cb356472bfd11833f30ac Mon Sep 17 00:00:00 2001 From: Makai Date: Sat, 21 Jun 2025 10:40:14 +0000 Subject: [PATCH 21/22] refactor: rewrite `adt_repr()`, `adt_discr_for_variant()` and `coroutine_discr_for_variant()` --- .../src/rustc_smir/context/impls.rs | 27 +++++++++++- .../src/stable_mir/compiler_interface.rs | 44 +++++++++++++++---- .../stable_mir/unstable/convert/stable/abi.rs | 28 ++++++++---- .../stable_mir/unstable/convert/stable/ty.rs | 8 +++- 4 files changed, 88 insertions(+), 19 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_smir/context/impls.rs b/compiler/rustc_smir/src/rustc_smir/context/impls.rs index c455be95b4d9a..a7cc81d0b70c4 100644 --- a/compiler/rustc_smir/src/rustc_smir/context/impls.rs +++ b/compiler/rustc_smir/src/rustc_smir/context/impls.rs @@ -4,13 +4,14 @@ use std::iter; -use rustc_abi::{Endian, Layout}; +use rustc_abi::{Endian, Layout, ReprOptions}; use rustc_hir::def::DefKind; use rustc_hir::{Attribute, LangItem}; use rustc_middle::mir::interpret::{AllocId, ConstAllocation, ErrorHandled, GlobalAlloc, Scalar}; use rustc_middle::mir::{BinOp, Body, Const as MirConst, ConstValue, UnOp}; use rustc_middle::ty::layout::{FnAbiOf, LayoutOf}; use rustc_middle::ty::print::{with_forced_trimmed_paths, with_no_trimmed_paths}; +use rustc_middle::ty::util::Discr; use rustc_middle::ty::{ AdtDef, AdtKind, AssocItem, Binder, ClosureKind, CoroutineArgsExt, EarlyBinder, ExistentialTraitRef, FnSig, GenericArgsRef, Instance, InstanceKind, IntrinsicDef, List, @@ -363,6 +364,11 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { self.tcx.is_lang_item(def_id, LangItem::CStr) } + /// Returns the representation options for this ADT. + pub fn adt_repr(&self, def: AdtDef<'tcx>) -> ReprOptions { + def.repr() + } + /// Retrieve the function signature for the given generic arguments. pub fn fn_sig( &self, @@ -394,6 +400,25 @@ impl<'tcx, B: Bridge> SmirCtxt<'tcx, B> { def.variants().len() } + /// Discriminant for a given variant index of AdtDef. + pub fn adt_discr_for_variant( + &self, + adt: AdtDef<'tcx>, + variant: rustc_abi::VariantIdx, + ) -> Discr<'tcx> { + adt.discriminant_for_variant(self.tcx, variant) + } + + /// Discriminant for a given variand index and args of a coroutine. + pub fn coroutine_discr_for_variant( + &self, + coroutine: DefId, + args: GenericArgsRef<'tcx>, + variant: rustc_abi::VariantIdx, + ) -> Discr<'tcx> { + args.as_coroutine().discriminant_for_variant(coroutine, self.tcx, variant) + } + /// The name of a variant. pub fn variant_name(&self, def: &'tcx VariantDef) -> String { def.name.to_string() diff --git a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs index bc7d0c6eabe45..e642e8b66e2b8 100644 --- a/compiler/rustc_smir/src/stable_mir/compiler_interface.rs +++ b/compiler/rustc_smir/src/stable_mir/compiler_interface.rs @@ -152,6 +152,9 @@ pub(crate) trait SmirInterface { /// Returns whether this definition is a C string. fn adt_is_cstr(&self, def: AdtDef) -> bool; + /// Returns the representation options for this ADT. + fn adt_repr(&self, def: AdtDef) -> ReprOptions; + /// Retrieve the function signature for the given generic arguments. fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig; @@ -167,6 +170,17 @@ pub(crate) trait SmirInterface { /// The number of variants in this ADT. fn adt_variants_len(&self, def: AdtDef) -> usize; + /// Discriminant for a given variant index of AdtDef. + fn adt_discr_for_variant(&self, adt: AdtDef, variant: VariantIdx) -> Discr; + + /// Discriminant for a given variand index and args of a coroutine. + fn coroutine_discr_for_variant( + &self, + coroutine: CoroutineDef, + args: &GenericArgs, + variant: VariantIdx, + ) -> Discr; + /// The name of a variant. fn variant_name(&self, def: VariantDef) -> Symbol; fn variant_fields(&self, def: VariantDef) -> Vec; @@ -588,8 +602,10 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { } /// Returns the representation options for this ADT - pub(crate) fn adt_repr(&self, def: AdtDef) -> ReprOptions { - self.cx.adt_repr(def) + fn adt_repr(&self, def: AdtDef) -> ReprOptions { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.adt_repr(def.internal(&mut *tables, cx.tcx)).stable(&mut *tables, cx) } /// Retrieve the function signature for the given generic arguments. @@ -632,19 +648,31 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { cx.adt_variants_len(def.internal(&mut *tables, cx.tcx)) } - /// Discriminant for a given variant index of AdtDef - pub(crate) fn adt_discr_for_variant(&self, adt: AdtDef, variant: VariantIdx) -> Discr { - self.cx.adt_discr_for_variant(adt, variant) + /// Discriminant for a given variant index of AdtDef. + fn adt_discr_for_variant(&self, adt: AdtDef, variant: VariantIdx) -> Discr { + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + cx.adt_discr_for_variant( + adt.internal(&mut *tables, cx.tcx), + variant.internal(&mut *tables, cx.tcx), + ) + .stable(&mut *tables, cx) } - /// Discriminant for a given variand index and args of a coroutine - pub(crate) fn coroutine_discr_for_variant( + /// Discriminant for a given variand index and args of a coroutine. + fn coroutine_discr_for_variant( &self, coroutine: CoroutineDef, args: &GenericArgs, variant: VariantIdx, ) -> Discr { - self.cx.coroutine_discr_for_variant(coroutine, args, variant) + let mut tables = self.tables.borrow_mut(); + let cx = &*self.cx.borrow(); + let tcx = cx.tcx; + let def = coroutine.def_id().internal(&mut *tables, tcx); + let args_ref = args.internal(&mut *tables, tcx); + cx.coroutine_discr_for_variant(def, args_ref, variant.internal(&mut *tables, tcx)) + .stable(&mut *tables, cx) } /// The name of a variant. diff --git a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs index 0d8ecf4df2af8..d8823a0d10c0e 100644 --- a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/abi.rs @@ -362,7 +362,11 @@ impl<'tcx> Stable<'tcx> for rustc_abi::WrappingRange { impl<'tcx> Stable<'tcx> for rustc_abi::ReprFlags { type T = ReprFlags; - fn stable(&self, _tables: &mut Tables<'_>) -> Self::T { + fn stable<'cx>( + &self, + _tables: &mut Tables<'cx, BridgeTys>, + _cx: &SmirCtxt<'cx, BridgeTys>, + ) -> Self::T { ReprFlags { is_simd: self.intersects(Self::IS_SIMD), is_c: self.intersects(Self::IS_C), @@ -375,11 +379,15 @@ impl<'tcx> Stable<'tcx> for rustc_abi::ReprFlags { impl<'tcx> Stable<'tcx> for rustc_abi::IntegerType { type T = IntegerType; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable<'cx>( + &self, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, + ) -> Self::T { match self { rustc_abi::IntegerType::Pointer(signed) => IntegerType::Pointer { is_signed: *signed }, rustc_abi::IntegerType::Fixed(integer, signed) => { - IntegerType::Fixed { length: integer.stable(tables), is_signed: *signed } + IntegerType::Fixed { length: integer.stable(tables, cx), is_signed: *signed } } } } @@ -388,12 +396,16 @@ impl<'tcx> Stable<'tcx> for rustc_abi::IntegerType { impl<'tcx> Stable<'tcx> for rustc_abi::ReprOptions { type T = ReprOptions; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { + fn stable<'cx>( + &self, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, + ) -> Self::T { ReprOptions { - int: self.int.map(|int| int.stable(tables)), - align: self.align.map(|align| align.stable(tables)), - pack: self.pack.map(|pack| pack.stable(tables)), - flags: self.flags.stable(tables), + int: self.int.map(|int| int.stable(tables, cx)), + align: self.align.map(|align| align.stable(tables, cx)), + pack: self.pack.map(|pack| pack.stable(tables, cx)), + flags: self.flags.stable(tables, cx), } } } diff --git a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs index 302f05932c194..ed1dc66981291 100644 --- a/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/convert/stable/ty.rs @@ -1140,7 +1140,11 @@ impl<'tcx> Stable<'tcx> for ty::ImplTraitInTraitData { impl<'tcx> Stable<'tcx> for rustc_middle::ty::util::Discr<'tcx> { type T = stable_mir::ty::Discr; - fn stable(&self, tables: &mut Tables<'_>) -> Self::T { - stable_mir::ty::Discr { val: self.val, ty: self.ty.stable(tables) } + fn stable<'cx>( + &self, + tables: &mut Tables<'cx, BridgeTys>, + cx: &SmirCtxt<'cx, BridgeTys>, + ) -> Self::T { + stable_mir::ty::Discr { val: self.val, ty: self.ty.stable(tables, cx) } } } From f88c65e880a7cb2ebeac3f4f634f2683faedd65c Mon Sep 17 00:00:00 2001 From: Makai Date: Sat, 21 Jun 2025 10:41:28 +0000 Subject: [PATCH 22/22] fix: `PointeeSized` bound for the `Stable` trait --- compiler/rustc_smir/src/rustc_smir/mod.rs | 1 - compiler/rustc_smir/src/stable_mir/unstable/mod.rs | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs index 3e40a4a80dbcc..370af9d4f2c20 100644 --- a/compiler/rustc_smir/src/rustc_smir/mod.rs +++ b/compiler/rustc_smir/src/rustc_smir/mod.rs @@ -15,7 +15,6 @@ use std::ops::Index; use bridge::*; use context::SmirCtxt; use rustc_data_structures::fx::{self, FxIndexMap}; -use rustc_data_structures::PointeeSized; use rustc_middle::mir; use rustc_middle::mir::interpret::AllocId; use rustc_middle::ty::{self, Ty, TyCtxt}; diff --git a/compiler/rustc_smir/src/stable_mir/unstable/mod.rs b/compiler/rustc_smir/src/stable_mir/unstable/mod.rs index 4fd10509b01f3..242ead2045204 100644 --- a/compiler/rustc_smir/src/stable_mir/unstable/mod.rs +++ b/compiler/rustc_smir/src/stable_mir/unstable/mod.rs @@ -4,6 +4,7 @@ //! any sort of conversion and usage of internal rustc code. So we //! restrict the usage of internal items to be inside this module. +use rustc_data_structures::PointeeSized; use rustc_hir::def::DefKind; use rustc_middle::ty::{List, Ty, TyCtxt}; use rustc_middle::{mir, ty}; @@ -143,7 +144,7 @@ pub trait InternalCx<'tcx>: Copy + Clone { /// and StableMIR constructs. However, they should be used seldomly and they have no influence /// in this crate semver. #[doc(hidden)] -pub trait Stable<'tcx> { +pub trait Stable<'tcx>: PointeeSized { /// The stable representation of the type implementing Stable. type T; /// Converts an object to the equivalent Stable MIR representation.