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`.

Author: makai410

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};

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`.

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};
-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::{
     ImplDef, ImplTrait, IntrinsicDef, LineInfo, MirConst, PolyFnSig, RigidTy, Span, TraitDecl,
     TraitDef, Ty, TyConst, TyConstId, TyKind, UintTy, VariantDef,
 };
+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;
 

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);

compiler/rustc_smir/src/stable_mir/convert/mod.rs renamed to 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<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.as_ref().map(|value| value.stable(tables, cx))
     }
@@ -46,10 +59,10 @@ where
 {
     type T = Result<T::T, E::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 {
         match self {
             Ok(val) => Ok(val.stable(tables, cx)),
@@ -63,10 +76,10 @@ where
     T: Stable<'tcx>,
 {
     type T = Vec<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.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<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 {
         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>;
-}