cleanup: re-export IndexedVal and fix some nits

Author: makai410

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,35 +13,35 @@ pub trait SmirError {
     fn from_internal<T: Debug>(err: T) -> Self;
 }
 
-macro_rules! make_def_trait {
+pub trait Prov<B: Bridge> {
+    fn new(aid: B::AllocId) -> Self;
+}
+
+macro_rules! make_bridge_trait {
     ($name:ident) => {
         pub trait $name<B: Bridge> {
             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<B: Bridge> {
-    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);

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

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<BridgeTys> 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<BridgeTys> 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

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.

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

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 {

compiler/rustc_smir/src/stable_mir/mod.rs

@@ -240,3 +240,40 @@ impl std::fmt::Debug for Opaque {
 pub fn opaque<T: Debug>(value: &T) -> Opaque {
     Opaque(format!("{value:?}"))
 }
+
+macro_rules! bridge_impl {
+    ($name: ident, $ty: ty) => {
+        impl rustc_smir::bridge::$name<compiler_interface::BridgeTys> 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<compiler_interface::BridgeTys> for stable_mir::ty::Prov {
+    fn new(aid: stable_mir::mir::alloc::AllocId) -> Self {
+        Self(aid)
+    }
+}

compiler/rustc_smir/src/stable_mir/ty.rs

@@ -1,18 +1,17 @@
 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::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);
@@ -1531,7 +1530,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)
             }