diff --git a/Cargo.lock b/Cargo.lock index 271a2f7962cac..945c48fe3ed31 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3271,8 +3271,8 @@ dependencies = [ "rustc_codegen_ssa", "rustc_driver", "rustc_driver_impl", - "rustc_smir", - "stable_mir", + "rustc_public", + "rustc_public_shim", "tikv-jemalloc-sys", ] @@ -3709,6 +3709,7 @@ dependencies = [ "rustc_passes", "rustc_pattern_analysis", "rustc_privacy", + "rustc_public", "rustc_query_system", "rustc_resolve", "rustc_session", @@ -3718,7 +3719,6 @@ dependencies = [ "rustc_ty_utils", "serde_json", "shlex", - "stable_mir", "tracing", "windows 0.61.3", ] @@ -4414,6 +4414,36 @@ dependencies = [ "rustc-literal-escaper", ] +[[package]] +name = "rustc_public" +version = "0.1.0-preview" +dependencies = [ + "rustc_abi", + "rustc_hir", + "rustc_middle", + "rustc_public_shim", + "rustc_session", + "rustc_span", + "rustc_target", + "scoped-tls", + "serde", + "tracing", +] + +[[package]] +name = "rustc_public_shim" +version = "0.0.0" +dependencies = [ + "rustc_abi", + "rustc_data_structures", + "rustc_hir", + "rustc_hir_pretty", + "rustc_middle", + "rustc_session", + "rustc_span", + "rustc_target", +] + [[package]] name = "rustc_query_impl" version = "0.0.0" @@ -4541,20 +4571,6 @@ dependencies = [ "windows 0.61.3", ] -[[package]] -name = "rustc_smir" -version = "0.0.0" -dependencies = [ - "rustc_abi", - "rustc_data_structures", - "rustc_hir", - "rustc_hir_pretty", - "rustc_middle", - "rustc_session", - "rustc_span", - "rustc_target", -] - [[package]] name = "rustc_span" version = "0.0.0" @@ -5102,22 +5118,6 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" -[[package]] -name = "stable_mir" -version = "0.1.0-preview" -dependencies = [ - "rustc_abi", - "rustc_hir", - "rustc_middle", - "rustc_session", - "rustc_smir", - "rustc_span", - "rustc_target", - "scoped-tls", - "serde", - "tracing", -] - [[package]] name = "stacker" version = "0.1.21" diff --git a/compiler/rustc/Cargo.toml b/compiler/rustc/Cargo.toml index f4caa3ef769d5..42cac3dd69650 100644 --- a/compiler/rustc/Cargo.toml +++ b/compiler/rustc/Cargo.toml @@ -13,11 +13,11 @@ rustc_codegen_ssa = { path = "../rustc_codegen_ssa" } rustc_driver = { path = "../rustc_driver" } rustc_driver_impl = { path = "../rustc_driver_impl" } -# Make sure rustc_smir ends up in the sysroot, because this -# crate is intended to be used by stable MIR consumers, which are not in-tree. -rustc_smir = { path = "../rustc_smir" } +rustc_public = { path = "../rustc_public" } -stable_mir = { path = "../stable_mir" } +# Make sure rustc_public_shim ends up in the sysroot, because this +# crate is intended to be used by stable MIR consumers, which are not in-tree. +rustc_public_shim = { path = "../rustc_public_shim" } # tidy-alphabetical-end [dependencies.tikv-jemalloc-sys] diff --git a/compiler/rustc_driver_impl/Cargo.toml b/compiler/rustc_driver_impl/Cargo.toml index 1971d06aad64d..9893c594a6733 100644 --- a/compiler/rustc_driver_impl/Cargo.toml +++ b/compiler/rustc_driver_impl/Cargo.toml @@ -41,6 +41,7 @@ rustc_parse = { path = "../rustc_parse" } rustc_passes = { path = "../rustc_passes" } rustc_pattern_analysis = { path = "../rustc_pattern_analysis" } rustc_privacy = { path = "../rustc_privacy" } +rustc_public = { path = "../rustc_public", features = ["rustc_internal"] } rustc_query_system = { path = "../rustc_query_system" } rustc_resolve = { path = "../rustc_resolve" } rustc_session = { path = "../rustc_session" } @@ -50,7 +51,6 @@ rustc_trait_selection = { path = "../rustc_trait_selection" } rustc_ty_utils = { path = "../rustc_ty_utils" } serde_json = "1.0.59" shlex = "1.0" -stable_mir = { path = "../stable_mir", features = ["rustc_internal"] } tracing = { version = "0.1.35" } # tidy-alphabetical-end diff --git a/compiler/rustc_driver_impl/src/pretty.rs b/compiler/rustc_driver_impl/src/pretty.rs index 688307a941f30..1604b704033bd 100644 --- a/compiler/rustc_driver_impl/src/pretty.rs +++ b/compiler/rustc_driver_impl/src/pretty.rs @@ -8,10 +8,10 @@ use rustc_middle::bug; use rustc_middle::mir::{write_mir_graphviz, write_mir_pretty}; use rustc_middle::ty::{self, TyCtxt}; use rustc_mir_build::thir::print::{thir_flat, thir_tree}; +use rustc_public::rustc_internal::pretty::write_smir_pretty; use rustc_session::Session; use rustc_session::config::{OutFileName, PpHirMode, PpMode, PpSourceMode}; use rustc_span::{FileName, Ident}; -use stable_mir::rustc_internal::pretty::write_smir_pretty; use tracing::debug; use {rustc_ast as ast, rustc_hir_pretty as pprust_hir}; diff --git a/compiler/stable_mir/Cargo.toml b/compiler/rustc_public/Cargo.toml similarity index 90% rename from compiler/stable_mir/Cargo.toml rename to compiler/rustc_public/Cargo.toml index 6777abce01d12..ec2c25a852059 100644 --- a/compiler/stable_mir/Cargo.toml +++ b/compiler/rustc_public/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "stable_mir" +name = "rustc_public" version = "0.1.0-preview" edition = "2024" @@ -8,8 +8,8 @@ edition = "2024" rustc_abi = { path = "../rustc_abi" } rustc_hir = { path = "../rustc_hir" } rustc_middle = { path = "../rustc_middle" } +rustc_public_shim = { path = "../rustc_public_shim" } rustc_session = { path = "../rustc_session" } -rustc_smir = { path = "../rustc_smir" } rustc_span = { path = "../rustc_span" } rustc_target = { path = "../rustc_target" } scoped-tls = "1.0" diff --git a/compiler/stable_mir/README.md b/compiler/rustc_public/README.md similarity index 100% rename from compiler/stable_mir/README.md rename to compiler/rustc_public/README.md diff --git a/compiler/stable_mir/rust-toolchain.toml b/compiler/rustc_public/rust-toolchain.toml similarity index 100% rename from compiler/stable_mir/rust-toolchain.toml rename to compiler/rustc_public/rust-toolchain.toml diff --git a/compiler/stable_mir/src/abi.rs b/compiler/rustc_public/src/abi.rs similarity index 100% rename from compiler/stable_mir/src/abi.rs rename to compiler/rustc_public/src/abi.rs diff --git a/compiler/stable_mir/src/alloc.rs b/compiler/rustc_public/src/alloc.rs similarity index 91% rename from compiler/stable_mir/src/alloc.rs rename to compiler/rustc_public/src/alloc.rs index 349b83231e383..c13a8323882ad 100644 --- a/compiler/stable_mir/src/alloc.rs +++ b/compiler/rustc_public/src/alloc.rs @@ -2,14 +2,14 @@ //! //! This module is responsible for constructing stable components. //! All operations requiring rustc queries must be delegated -//! to `rustc_smir::alloc` to maintain stability guarantees. +//! to `rustc_public_shim::alloc` to maintain stability guarantees. 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::{Tables, alloc}; +use rustc_public_shim::bridge::SmirError; +use rustc_public_shim::context::SmirCtxt; +use rustc_public_shim::{Tables, alloc}; use super::Error; use super::compiler_interface::BridgeTys; @@ -59,7 +59,7 @@ pub(crate) fn try_new_allocation<'tcx>( } ConstValue::Indirect { alloc_id, offset } => { let alloc = alloc::try_new_indirect(alloc_id, cx); - use rustc_smir::context::SmirAllocRange; + use rustc_public_shim::context::SmirAllocRange; Ok(allocation_filter(&alloc.0, cx.alloc_range(offset, layout.size), tables, cx)) } } diff --git a/compiler/stable_mir/src/compiler_interface.rs b/compiler/rustc_public/src/compiler_interface.rs similarity index 99% rename from compiler/stable_mir/src/compiler_interface.rs rename to compiler/rustc_public/src/compiler_interface.rs index 50c2f02e6adef..69f1db5f574de 100644 --- a/compiler/stable_mir/src/compiler_interface.rs +++ b/compiler/rustc_public/src/compiler_interface.rs @@ -6,8 +6,8 @@ use std::cell::Cell; use rustc_hir::def::DefKind; -use rustc_smir::context::SmirCtxt; -use rustc_smir::{Bridge, SmirContainer}; +use rustc_public_shim::context::SmirCtxt; +use rustc_public_shim::{Bridge, SmirContainer}; use tracing::debug; use crate::abi::{FnAbi, Layout, LayoutShape, ReprOptions}; @@ -68,7 +68,7 @@ impl Bridge for BridgeTys { /// Stable public API for querying compiler information. /// -/// All queries are delegated to [`rustc_smir::context::SmirCtxt`] that provides +/// All queries are delegated to [`rustc_public_shim::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. @@ -567,7 +567,7 @@ impl<'tcx> SmirInterface for SmirContainer<'tcx, BridgeTys> { 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; + use rustc_public_shim::context::SmirTy; ForeignItemKind::Type(tables.intern_ty(cx.new_foreign(def_id))) } def_kind => unreachable!("Unexpected kind for a foreign item: {:?}", def_kind), diff --git a/compiler/stable_mir/src/crate_def.rs b/compiler/rustc_public/src/crate_def.rs similarity index 100% rename from compiler/stable_mir/src/crate_def.rs rename to compiler/rustc_public/src/crate_def.rs diff --git a/compiler/stable_mir/src/error.rs b/compiler/rustc_public/src/error.rs similarity index 98% rename from compiler/stable_mir/src/error.rs rename to compiler/rustc_public/src/error.rs index 702134b0c4c2c..c5153d8b39fb0 100644 --- a/compiler/stable_mir/src/error.rs +++ b/compiler/rustc_public/src/error.rs @@ -7,7 +7,7 @@ use std::fmt::{Debug, Display, Formatter}; use std::{fmt, io}; -use rustc_smir::bridge::SmirError; +use rustc_public_shim::bridge::SmirError; macro_rules! error { ($fmt: literal $(,)?) => { Error(format!($fmt)) }; diff --git a/compiler/stable_mir/src/lib.rs b/compiler/rustc_public/src/lib.rs similarity index 95% rename from compiler/stable_mir/src/lib.rs rename to compiler/rustc_public/src/lib.rs index 0a2e4e71afc19..c6946e3bbe652 100644 --- a/compiler/stable_mir/src/lib.rs +++ b/compiler/rustc_public/src/lib.rs @@ -22,9 +22,9 @@ use std::fmt::Debug; use std::{fmt, io}; -pub(crate) use rustc_smir::IndexedVal; -use rustc_smir::Tables; -use rustc_smir::context::SmirCtxt; +pub(crate) use rustc_public_shim::IndexedVal; +use rustc_public_shim::Tables; +use rustc_public_shim::context::SmirCtxt; /// Export the rustc_internal APIs. Note that this module has no stability /// guarantees and it is not taken into account for semver. #[cfg(feature = "rustc_internal")] @@ -244,7 +244,7 @@ pub fn opaque(value: &T) -> Opaque { macro_rules! bridge_impl { ($name: ident, $ty: ty) => { - impl rustc_smir::bridge::$name for $ty { + impl rustc_public_shim::bridge::$name for $ty { fn new(def: crate::DefId) -> Self { Self(def) } @@ -273,13 +273,15 @@ bridge_impl!(AssocDef, crate::ty::AssocDef); bridge_impl!(OpaqueDef, crate::ty::OpaqueDef); bridge_impl!(StaticDef, crate::mir::mono::StaticDef); -impl rustc_smir::bridge::Prov for crate::ty::Prov { +impl rustc_public_shim::bridge::Prov for crate::ty::Prov { fn new(aid: crate::mir::alloc::AllocId) -> Self { Self(aid) } } -impl rustc_smir::bridge::Allocation for crate::ty::Allocation { +impl rustc_public_shim::bridge::Allocation + for crate::ty::Allocation +{ fn new<'tcx>( bytes: Vec>, ptrs: Vec<(usize, rustc_middle::mir::interpret::AllocId)>, diff --git a/compiler/stable_mir/src/mir.rs b/compiler/rustc_public/src/mir.rs similarity index 100% rename from compiler/stable_mir/src/mir.rs rename to compiler/rustc_public/src/mir.rs diff --git a/compiler/stable_mir/src/mir/alloc.rs b/compiler/rustc_public/src/mir/alloc.rs similarity index 100% rename from compiler/stable_mir/src/mir/alloc.rs rename to compiler/rustc_public/src/mir/alloc.rs diff --git a/compiler/stable_mir/src/mir/body.rs b/compiler/rustc_public/src/mir/body.rs similarity index 99% rename from compiler/stable_mir/src/mir/body.rs rename to compiler/rustc_public/src/mir/body.rs index a9fe360723230..28a7aa6e75821 100644 --- a/compiler/stable_mir/src/mir/body.rs +++ b/compiler/rustc_public/src/mir/body.rs @@ -674,7 +674,7 @@ pub enum AggregateKind { Tuple, Adt(AdtDef, VariantIdx, GenericArgs, Option, Option), Closure(ClosureDef, GenericArgs), - // FIXME(stable_mir): Movability here is redundant + // FIXME(rustc_public): Movability here is redundant Coroutine(CoroutineDef, GenericArgs, Movability), CoroutineClosure(CoroutineClosureDef, GenericArgs), RawPtr(Ty, Mutability), diff --git a/compiler/stable_mir/src/mir/mono.rs b/compiler/rustc_public/src/mir/mono.rs similarity index 99% rename from compiler/stable_mir/src/mir/mono.rs rename to compiler/rustc_public/src/mir/mono.rs index c54fcecac9f1e..101f437468a74 100644 --- a/compiler/stable_mir/src/mir/mono.rs +++ b/compiler/rustc_public/src/mir/mono.rs @@ -1,7 +1,7 @@ use std::fmt::{Debug, Formatter}; use std::io; -use rustc_smir::bridge::SmirError; +use rustc_public_shim::bridge::SmirError; use serde::Serialize; use crate::abi::FnAbi; diff --git a/compiler/stable_mir/src/mir/pretty.rs b/compiler/rustc_public/src/mir/pretty.rs similarity index 100% rename from compiler/stable_mir/src/mir/pretty.rs rename to compiler/rustc_public/src/mir/pretty.rs diff --git a/compiler/stable_mir/src/mir/visit.rs b/compiler/rustc_public/src/mir/visit.rs similarity index 100% rename from compiler/stable_mir/src/mir/visit.rs rename to compiler/rustc_public/src/mir/visit.rs diff --git a/compiler/stable_mir/src/rustc_internal/mod.rs b/compiler/rustc_public/src/rustc_internal/mod.rs similarity index 96% rename from compiler/stable_mir/src/rustc_internal/mod.rs rename to compiler/rustc_public/src/rustc_internal/mod.rs index c1ed03ade7528..c21d727070926 100644 --- a/compiler/stable_mir/src/rustc_internal/mod.rs +++ b/compiler/rustc_public/src/rustc_internal/mod.rs @@ -6,8 +6,8 @@ use std::cell::{Cell, RefCell}; use rustc_middle::ty::TyCtxt; -use rustc_smir::context::SmirCtxt; -use rustc_smir::{Bridge, SmirContainer, Tables}; +use rustc_public_shim::context::SmirCtxt; +use rustc_public_shim::{Bridge, SmirContainer, Tables}; use rustc_span::def_id::CrateNum; use scoped_tls::scoped_thread_local; @@ -105,11 +105,11 @@ where /// # extern crate rustc_interface; /// # extern crate rustc_middle; /// # #[macro_use] -/// # extern crate stable_mir; +/// # extern crate rustc_public; /// # /// # fn main() { /// # use std::ops::ControlFlow; -/// # use stable_mir::CompilerError; +/// # use rustc_public::CompilerError; /// fn analyze_code() -> ControlFlow<(), ()> { /// // Your code goes in here. /// # ControlFlow::Continue(()) @@ -125,11 +125,11 @@ where /// # extern crate rustc_interface; /// # extern crate rustc_middle; /// # #[macro_use] -/// # extern crate stable_mir; +/// # extern crate rustc_public; /// # /// # fn main() { /// # use std::ops::ControlFlow; -/// # use stable_mir::CompilerError; +/// # use rustc_public::CompilerError; /// fn analyze_code(extra_args: Vec) -> ControlFlow<(), ()> { /// # let _ = extra_args; /// // Your code goes in here. @@ -187,8 +187,8 @@ macro_rules! run_driver { use rustc_driver::{Callbacks, Compilation, run_compiler}; use rustc_middle::ty::TyCtxt; use rustc_interface::interface; - use stable_mir::rustc_internal; - use stable_mir::CompilerError; + use rustc_public::rustc_internal; + use rustc_public::CompilerError; use std::ops::ControlFlow; pub struct StableMir ControlFlow> diff --git a/compiler/stable_mir/src/rustc_internal/pretty.rs b/compiler/rustc_public/src/rustc_internal/pretty.rs similarity index 100% rename from compiler/stable_mir/src/rustc_internal/pretty.rs rename to compiler/rustc_public/src/rustc_internal/pretty.rs diff --git a/compiler/stable_mir/src/target.rs b/compiler/rustc_public/src/target.rs similarity index 100% rename from compiler/stable_mir/src/target.rs rename to compiler/rustc_public/src/target.rs diff --git a/compiler/stable_mir/src/ty.rs b/compiler/rustc_public/src/ty.rs similarity index 99% rename from compiler/stable_mir/src/ty.rs rename to compiler/rustc_public/src/ty.rs index 87d31cf9713d1..bc67a2f987d9e 100644 --- a/compiler/stable_mir/src/ty.rs +++ b/compiler/rustc_public/src/ty.rs @@ -560,7 +560,7 @@ pub enum RigidTy { FnDef(FnDef, GenericArgs), FnPtr(PolyFnSig), Closure(ClosureDef, GenericArgs), - // FIXME(stable_mir): Movability here is redundant + // FIXME(rustc_public): Movability here is redundant Coroutine(CoroutineDef, GenericArgs, Movability), CoroutineClosure(CoroutineClosureDef, GenericArgs), Dynamic(Vec>, Region, DynKind), diff --git a/compiler/stable_mir/src/unstable/convert/internal.rs b/compiler/rustc_public/src/unstable/convert/internal.rs similarity index 99% rename from compiler/stable_mir/src/unstable/convert/internal.rs rename to compiler/rustc_public/src/unstable/convert/internal.rs index 04b2e57262178..4452bb24d6303 100644 --- a/compiler/stable_mir/src/unstable/convert/internal.rs +++ b/compiler/rustc_public/src/unstable/convert/internal.rs @@ -3,10 +3,10 @@ //! This module will only include a few constructs to allow users to invoke internal rustc APIs //! due to incomplete stable coverage. -// Prefer importing stable_mir over internal rustc constructs to make this file more readable. +// Prefer importing rustc_public 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::Tables; +use rustc_public_shim::Tables; use crate::abi::Layout; use crate::compiler_interface::BridgeTys; diff --git a/compiler/stable_mir/src/unstable/convert/mod.rs b/compiler/rustc_public/src/unstable/convert/mod.rs similarity index 92% rename from compiler/stable_mir/src/unstable/convert/mod.rs rename to compiler/rustc_public/src/unstable/convert/mod.rs index aad92325861de..cefafe2fadf64 100644 --- a/compiler/stable_mir/src/unstable/convert/mod.rs +++ b/compiler/rustc_public/src/unstable/convert/mod.rs @@ -1,15 +1,15 @@ //! 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. +//! and it should be added as when needed to be passed as input to rustc_public_shim 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. +//! These should be done via `rustc_public_shim` APIs, but it's possible to access ADT fields directly. use std::ops::RangeInclusive; -use rustc_smir::Tables; -use rustc_smir::context::SmirCtxt; +use rustc_public_shim::Tables; +use rustc_public_shim::context::SmirCtxt; use super::Stable; use crate::compiler_interface::BridgeTys; diff --git a/compiler/stable_mir/src/unstable/convert/stable/abi.rs b/compiler/rustc_public/src/unstable/convert/stable/abi.rs similarity index 99% rename from compiler/stable_mir/src/unstable/convert/stable/abi.rs rename to compiler/rustc_public/src/unstable/convert/stable/abi.rs index 8fdaa69c30526..f2499d29cdc17 100644 --- a/compiler/stable_mir/src/unstable/convert/stable/abi.rs +++ b/compiler/rustc_public/src/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_public_shim::Tables; +use rustc_public_shim::context::SmirCtxt; use rustc_target::callconv; use crate::abi::{ diff --git a/compiler/stable_mir/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs similarity index 99% rename from compiler/stable_mir/src/unstable/convert/stable/mir.rs rename to compiler/rustc_public/src/unstable/convert/stable/mir.rs index ad39fc3760094..f8e96652ee028 100644 --- a/compiler/stable_mir/src/unstable/convert/stable/mir.rs +++ b/compiler/rustc_public/src/unstable/convert/stable/mir.rs @@ -2,9 +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_public_shim::Tables; +use rustc_public_shim::bridge::SmirError; +use rustc_public_shim::context::SmirCtxt; use crate::compiler_interface::BridgeTys; use crate::mir::alloc::GlobalAlloc; @@ -821,7 +821,7 @@ impl<'tcx> Stable<'tcx> for mir::interpret::Allocation { tables: &mut Tables<'cx, BridgeTys>, cx: &SmirCtxt<'cx, BridgeTys>, ) -> Self::T { - use rustc_smir::context::SmirAllocRange; + use rustc_public_shim::context::SmirAllocRange; alloc::allocation_filter( self, cx.alloc_range(rustc_abi::Size::ZERO, self.size()), diff --git a/compiler/stable_mir/src/unstable/convert/stable/mod.rs b/compiler/rustc_public/src/unstable/convert/stable/mod.rs similarity index 97% rename from compiler/stable_mir/src/unstable/convert/stable/mod.rs rename to compiler/rustc_public/src/unstable/convert/stable/mod.rs index e7f14bbdfc8e4..7e1a0c9d352f3 100644 --- a/compiler/stable_mir/src/unstable/convert/stable/mod.rs +++ b/compiler/rustc_public/src/unstable/convert/stable/mod.rs @@ -1,8 +1,8 @@ //! Conversion of internal Rust compiler items to stable ones. use rustc_abi::FieldIdx; -use rustc_smir::Tables; -use rustc_smir::context::SmirCtxt; +use rustc_public_shim::Tables; +use rustc_public_shim::context::SmirCtxt; use super::Stable; use crate::compiler_interface::BridgeTys; diff --git a/compiler/stable_mir/src/unstable/convert/stable/ty.rs b/compiler/rustc_public/src/unstable/convert/stable/ty.rs similarity index 99% rename from compiler/stable_mir/src/unstable/convert/stable/ty.rs rename to compiler/rustc_public/src/unstable/convert/stable/ty.rs index 366f7ea01d44e..7ffc3611eadda 100644 --- a/compiler/stable_mir/src/unstable/convert/stable/ty.rs +++ b/compiler/rustc_public/src/unstable/convert/stable/ty.rs @@ -2,8 +2,8 @@ use rustc_middle::ty::Ty; use rustc_middle::{bug, mir, ty}; -use rustc_smir::Tables; -use rustc_smir::context::SmirCtxt; +use rustc_public_shim::Tables; +use rustc_public_shim::context::SmirCtxt; use crate::alloc; use crate::compiler_interface::BridgeTys; diff --git a/compiler/stable_mir/src/unstable/internal_cx/mod.rs b/compiler/rustc_public/src/unstable/internal_cx/mod.rs similarity index 100% rename from compiler/stable_mir/src/unstable/internal_cx/mod.rs rename to compiler/rustc_public/src/unstable/internal_cx/mod.rs diff --git a/compiler/stable_mir/src/unstable/internal_cx/traits.rs b/compiler/rustc_public/src/unstable/internal_cx/traits.rs similarity index 100% rename from compiler/stable_mir/src/unstable/internal_cx/traits.rs rename to compiler/rustc_public/src/unstable/internal_cx/traits.rs diff --git a/compiler/stable_mir/src/unstable/mod.rs b/compiler/rustc_public/src/unstable/mod.rs similarity index 96% rename from compiler/stable_mir/src/unstable/mod.rs rename to compiler/rustc_public/src/unstable/mod.rs index 51c31e212f59c..5377130828d20 100644 --- a/compiler/stable_mir/src/unstable/mod.rs +++ b/compiler/rustc_public/src/unstable/mod.rs @@ -9,8 +9,8 @@ use std::marker::PointeeSized; 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; +use rustc_public_shim::Tables; +use rustc_public_shim::context::SmirCtxt; use super::compiler_interface::BridgeTys; use crate::{CtorKind, ItemKind}; @@ -21,7 +21,7 @@ mod internal_cx; /// 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 [`rustc_smir::context::SmirCtxt`]. +/// should go through [`rustc_public_shim::context::SmirCtxt`]. pub trait InternalCx<'tcx>: Copy + Clone { fn tcx(self) -> TyCtxt<'tcx>; diff --git a/compiler/stable_mir/src/visitor.rs b/compiler/rustc_public/src/visitor.rs similarity index 100% rename from compiler/stable_mir/src/visitor.rs rename to compiler/rustc_public/src/visitor.rs diff --git a/compiler/rustc_smir/.gitignore b/compiler/rustc_public_shim/.gitignore similarity index 100% rename from compiler/rustc_smir/.gitignore rename to compiler/rustc_public_shim/.gitignore diff --git a/compiler/rustc_smir/Cargo.toml b/compiler/rustc_public_shim/Cargo.toml similarity index 94% rename from compiler/rustc_smir/Cargo.toml rename to compiler/rustc_public_shim/Cargo.toml index b7ea478f73153..b033ecfe31a3b 100644 --- a/compiler/rustc_smir/Cargo.toml +++ b/compiler/rustc_public_shim/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "rustc_smir" +name = "rustc_public_shim" version = "0.0.0" edition = "2024" diff --git a/compiler/rustc_smir/src/alloc.rs b/compiler/rustc_public_shim/src/alloc.rs similarity index 97% rename from compiler/rustc_smir/src/alloc.rs rename to compiler/rustc_public_shim/src/alloc.rs index fd3cf24edb500..23bbaddce06d5 100644 --- a/compiler/rustc_smir/src/alloc.rs +++ b/compiler/rustc_public_shim/src/alloc.rs @@ -1,7 +1,7 @@ //! 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` +//! the actual memory allocations. The stable interface in `rustc_public::alloc` //! delegates all query-related operations to this implementation. use rustc_abi::{Size, TyAndLayout}; diff --git a/compiler/rustc_smir/src/bridge.rs b/compiler/rustc_public_shim/src/bridge.rs similarity index 93% rename from compiler/rustc_smir/src/bridge.rs rename to compiler/rustc_public_shim/src/bridge.rs index a31eb93d0e80d..146984271c7fa 100644 --- a/compiler/rustc_smir/src/bridge.rs +++ b/compiler/rustc_public_shim/src/bridge.rs @@ -1,8 +1,8 @@ //! Defines a set of traits that is used for abstracting -//! stable_mir's components that are needed in rustc_smir. +//! rustc_public's components that are needed in rustc_public_shim. //! //! These traits are really useful when programming -//! in stable_mir-agnostic settings. +//! in rustc_public-agnostic settings. use std::fmt::Debug; diff --git a/compiler/rustc_smir/src/builder.rs b/compiler/rustc_public_shim/src/builder.rs similarity index 100% rename from compiler/rustc_smir/src/builder.rs rename to compiler/rustc_public_shim/src/builder.rs diff --git a/compiler/rustc_smir/src/context/impls.rs b/compiler/rustc_public_shim/src/context/impls.rs similarity index 100% rename from compiler/rustc_smir/src/context/impls.rs rename to compiler/rustc_public_shim/src/context/impls.rs diff --git a/compiler/rustc_smir/src/context/mod.rs b/compiler/rustc_public_shim/src/context/mod.rs similarity index 100% rename from compiler/rustc_smir/src/context/mod.rs rename to compiler/rustc_public_shim/src/context/mod.rs diff --git a/compiler/rustc_smir/src/context/traits.rs b/compiler/rustc_public_shim/src/context/traits.rs similarity index 100% rename from compiler/rustc_smir/src/context/traits.rs rename to compiler/rustc_public_shim/src/context/traits.rs diff --git a/compiler/rustc_smir/src/lib.rs b/compiler/rustc_public_shim/src/lib.rs similarity index 98% rename from compiler/rustc_smir/src/lib.rs rename to compiler/rustc_public_shim/src/lib.rs index fbebf98df7da7..652a8093a8791 100644 --- a/compiler/rustc_smir/src/lib.rs +++ b/compiler/rustc_public_shim/src/lib.rs @@ -3,7 +3,7 @@ //! This crate is responsible for building Stable MIR components from internal components. //! //! This crate is not intended to be invoked directly by users. -//! This crate is the public API of rustc that will be invoked by the `stable_mir` crate. +//! This crate is the public API of rustc that will be invoked by the `rustc_public` crate. //! //! For more information see //! @@ -42,7 +42,7 @@ pub mod bridge; mod builder; pub mod context; -#[deprecated(note = "please use `stable_mir::rustc_internal` instead")] +#[deprecated(note = "please use `rustc_public::rustc_internal` instead")] pub mod rustc_internal {} /// A container which is used for TLS. @@ -211,7 +211,7 @@ impl<'tcx, B: Bridge> Tables<'tcx, B> { } /// A trait defining types that are used to emulate StableMIR components, which is really -/// useful when programming in stable_mir-agnostic settings. +/// useful when programming in rustc_public-agnostic settings. pub trait Bridge: Sized { type DefId: Copy + Debug + PartialEq + IndexedVal; type AllocId: Copy + Debug + PartialEq + IndexedVal; diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs index 1282a89a5e4f6..a77abe2f2de11 100644 --- a/src/bootstrap/src/core/build_steps/compile.rs +++ b/src/bootstrap/src/core/build_steps/compile.rs @@ -2400,10 +2400,10 @@ pub fn run_cargo( keep = true; } else if rlib_only_metadata { if filename.contains("jemalloc_sys") - || filename.contains("rustc_smir") - || filename.contains("stable_mir") + || filename.contains("rustc_public_shim") + || filename.contains("rustc_public") { - // jemalloc_sys and rustc_smir are not linked into librustc_driver.so, + // jemalloc_sys and rustc_public_shim are not linked into librustc_driver.so, // so we need to distribute them as rlib to be able to use them. keep |= filename.ends_with(".rlib"); } else { diff --git a/tests/ui-fulldeps/stable-mir/check_abi.rs b/tests/ui-fulldeps/stable-mir/check_abi.rs index 9d83dd9ce1ade..fc2227d147db1 100644 --- a/tests/ui-fulldeps/stable-mir/check_abi.rs +++ b/tests/ui-fulldeps/stable-mir/check_abi.rs @@ -14,17 +14,17 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::abi::{ +use rustc_public::abi::{ ArgAbi, CallConvention, FieldsShape, IntegerLength, PassMode, Primitive, Scalar, ValueAbi, VariantsShape, }; -use stable_mir::mir::MirVisitor; -use stable_mir::mir::mono::Instance; -use stable_mir::target::MachineInfo; -use stable_mir::ty::{AdtDef, RigidTy, Ty, TyKind}; -use stable_mir::{CrateDef, CrateItem, CrateItems, ItemKind}; +use rustc_public::mir::MirVisitor; +use rustc_public::mir::mono::Instance; +use rustc_public::target::MachineInfo; +use rustc_public::ty::{AdtDef, RigidTy, Ty, TyKind}; +use rustc_public::{CrateDef, CrateItem, CrateItems, ItemKind}; use std::assert_matches::assert_matches; use std::collections::HashSet; use std::convert::TryFrom; @@ -36,7 +36,7 @@ const CRATE_NAME: &str = "input"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_stable_mir() -> ControlFlow<()> { // Find items in the local crate. - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); // Test fn_abi let target_fn = *get_item(&items, (ItemKind::Fn, "fn_abi")).unwrap(); @@ -69,7 +69,7 @@ fn test_stable_mir() -> ControlFlow<()> { assert!(ptr_variadic_fn_abi.c_variadic); assert_eq!(ptr_variadic_fn_abi.args.len(), 1); - let entry = stable_mir::entry_fn().unwrap(); + let entry = rustc_public::entry_fn().unwrap(); let main_fn = Instance::try_from(entry).unwrap(); let mut visitor = AdtDefVisitor::default(); visitor.visit_body(&main_fn.body().unwrap()); @@ -147,7 +147,7 @@ fn check_niche(abi: &ArgAbi) { fn get_item<'a>( items: &'a CrateItems, item: (ItemKind, &str), -) -> Option<&'a stable_mir::CrateItem> { +) -> Option<&'a rustc_public::CrateItem> { items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1) } @@ -157,7 +157,7 @@ struct AdtDefVisitor { } impl MirVisitor for AdtDefVisitor { - fn visit_ty(&mut self, ty: &Ty, _location: stable_mir::mir::visit::Location) { + fn visit_ty(&mut self, ty: &Ty, _location: rustc_public::mir::visit::Location) { if let TyKind::RigidTy(RigidTy::Adt(adt, _)) = ty.kind() { self.adt_defs.insert(adt); } diff --git a/tests/ui-fulldeps/stable-mir/check_allocation.rs b/tests/ui-fulldeps/stable-mir/check_allocation.rs index c2d1d5d873be3..83845a9aa422b 100644 --- a/tests/ui-fulldeps/stable-mir/check_allocation.rs +++ b/tests/ui-fulldeps/stable-mir/check_allocation.rs @@ -17,7 +17,7 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; use std::ascii::Char; use std::assert_matches::assert_matches; @@ -27,19 +27,19 @@ use std::ffi::CStr; use std::io::Write; use std::ops::ControlFlow; -use stable_mir::crate_def::CrateDef; -use stable_mir::mir::Body; -use stable_mir::mir::alloc::GlobalAlloc; -use stable_mir::mir::mono::{Instance, StaticDef}; -use stable_mir::ty::{Allocation, ConstantKind}; -use stable_mir::{CrateItem, CrateItems, ItemKind}; +use rustc_public::crate_def::CrateDef; +use rustc_public::mir::Body; +use rustc_public::mir::alloc::GlobalAlloc; +use rustc_public::mir::mono::{Instance, StaticDef}; +use rustc_public::ty::{Allocation, ConstantKind}; +use rustc_public::{CrateItem, CrateItems, ItemKind}; const CRATE_NAME: &str = "input"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_stable_mir() -> ControlFlow<()> { // Find items in the local crate. - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); check_foo(*get_item(&items, (ItemKind::Static, "FOO")).unwrap()); check_bar(*get_item(&items, (ItemKind::Static, "BAR")).unwrap()); check_len(*get_item(&items, (ItemKind::Static, "LEN")).unwrap()); @@ -164,7 +164,7 @@ fn check_other_consts(item: CrateItem) { } let bool_id = bool_id.unwrap(); let char_id = char_id.unwrap(); - // FIXME(stable_mir): add `read_ptr` to `Allocation` + // FIXME(rustc_public): add `read_ptr` to `Allocation` assert_ne!(bool_id, char_id); } @@ -196,7 +196,7 @@ fn check_len(item: CrateItem) { fn get_item<'a>( items: &'a CrateItems, item: (ItemKind, &str), -) -> Option<&'a stable_mir::CrateItem> { +) -> Option<&'a rustc_public::CrateItem> { items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1) } diff --git a/tests/ui-fulldeps/stable-mir/check_assoc_items.rs b/tests/ui-fulldeps/stable-mir/check_assoc_items.rs index 574f77978541b..1557991f8cabf 100644 --- a/tests/ui-fulldeps/stable-mir/check_assoc_items.rs +++ b/tests/ui-fulldeps/stable-mir/check_assoc_items.rs @@ -14,20 +14,20 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; -extern crate stable_mir; +extern crate rustc_public; use std::collections::HashSet; use std::io::Write; use std::ops::ControlFlow; -use stable_mir::ty::*; -use stable_mir::{CrateDef, *}; +use rustc_public::ty::*; +use rustc_public::{CrateDef, *}; const CRATE_NAME: &str = "crate_assoc_items"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_assoc_items() -> ControlFlow<()> { - let local_crate = stable_mir::local_crate(); + let local_crate = rustc_public::local_crate(); check_items( &local_crate.fn_defs(), &[ diff --git a/tests/ui-fulldeps/stable-mir/check_attribute.rs b/tests/ui-fulldeps/stable-mir/check_attribute.rs index f234c658dfd1b..d8807872ec46a 100644 --- a/tests/ui-fulldeps/stable-mir/check_attribute.rs +++ b/tests/ui-fulldeps/stable-mir/check_attribute.rs @@ -13,9 +13,9 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::{CrateDef, CrateItems}; +use rustc_public::{CrateDef, CrateItems}; use std::io::Write; use std::ops::ControlFlow; @@ -24,7 +24,7 @@ const CRATE_NAME: &str = "input"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_stable_mir() -> ControlFlow<()> { // Find items in the local crate. - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); test_tool(&items); @@ -46,7 +46,7 @@ fn test_tool(items: &CrateItems) { fn get_item<'a>( items: &'a CrateItems, name: &str, -) -> Option<&'a stable_mir::CrateItem> { +) -> Option<&'a rustc_public::CrateItem> { items.iter().find(|crate_item| crate_item.name() == name) } diff --git a/tests/ui-fulldeps/stable-mir/check_binop.rs b/tests/ui-fulldeps/stable-mir/check_binop.rs index 748c2088a3017..aa089a5d12578 100644 --- a/tests/ui-fulldeps/stable-mir/check_binop.rs +++ b/tests/ui-fulldeps/stable-mir/check_binop.rs @@ -13,12 +13,12 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::mir::mono::Instance; -use stable_mir::mir::visit::{Location, MirVisitor}; -use stable_mir::mir::{LocalDecl, Rvalue, Statement, StatementKind, Terminator, TerminatorKind}; -use stable_mir::ty::{RigidTy, TyKind}; +use rustc_public::mir::mono::Instance; +use rustc_public::mir::visit::{Location, MirVisitor}; +use rustc_public::mir::{LocalDecl, Rvalue, Statement, StatementKind, Terminator, TerminatorKind}; +use rustc_public::ty::{RigidTy, TyKind}; use std::collections::HashSet; use std::convert::TryFrom; use std::io::Write; @@ -27,7 +27,7 @@ use std::ops::ControlFlow; /// This function tests that we can correctly get type information from binary operations. fn test_binops() -> ControlFlow<()> { // Find items in the local crate. - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); let mut instances = items.into_iter().map(|item| Instance::try_from(item).unwrap()).collect::>(); while let Some(instance) = instances.pop() { diff --git a/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs b/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs index 2af32afc1f7f2..725b538b0fe51 100644 --- a/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs +++ b/tests/ui-fulldeps/stable-mir/check_coroutine_body.rs @@ -14,18 +14,18 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; use std::io::Write; use std::ops::ControlFlow; -use stable_mir::mir::Body; -use stable_mir::ty::{RigidTy, TyKind}; +use rustc_public::mir::Body; +use rustc_public::ty::{RigidTy, TyKind}; const CRATE_NAME: &str = "crate_coroutine_body"; fn test_coroutine_body() -> ControlFlow<()> { - let crate_items = stable_mir::all_local_items(); + let crate_items = rustc_public::all_local_items(); if let Some(body) = crate_items.iter().find_map(|item| { let item_ty = item.ty(); if let TyKind::RigidTy(RigidTy::Coroutine(def, ..)) = &item_ty.kind() { diff --git a/tests/ui-fulldeps/stable-mir/check_crate_defs.rs b/tests/ui-fulldeps/stable-mir/check_crate_defs.rs index d3929c5e48be5..27d5b0bc23882 100644 --- a/tests/ui-fulldeps/stable-mir/check_crate_defs.rs +++ b/tests/ui-fulldeps/stable-mir/check_crate_defs.rs @@ -14,9 +14,9 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::CrateDef; +use rustc_public::CrateDef; use std::collections::HashSet; use std::io::Write; use std::ops::ControlFlow; @@ -26,7 +26,7 @@ const CRATE_NAME: &str = "crate_defs"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_stable_mir() -> ControlFlow<()> { // Find items in the local crate. - let local = stable_mir::local_crate(); + let local = rustc_public::local_crate(); check_items(&local.statics(), &["PRIVATE_STATIC", "dummy::PUBLIC_STATIC"]); check_items( &local.fn_defs(), @@ -44,7 +44,7 @@ fn test_stable_mir() -> ControlFlow<()> { // Find items inside core crate. // FIXME: We are currently missing primitive type methods and trait implementations for external // crates. - let core = stable_mir::find_crates("core").pop().expect("Cannot find `core` crate"); + let core = rustc_public::find_crates("core").pop().expect("Cannot find `core` crate"); contains( &core.fn_defs(), &[ diff --git a/tests/ui-fulldeps/stable-mir/check_def_ty.rs b/tests/ui-fulldeps/stable-mir/check_def_ty.rs index 101e7eb912121..b5954352dc027 100644 --- a/tests/ui-fulldeps/stable-mir/check_def_ty.rs +++ b/tests/ui-fulldeps/stable-mir/check_def_ty.rs @@ -14,10 +14,10 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::ty::{Ty, ForeignItemKind}; -use stable_mir::*; +use rustc_public::ty::{Ty, ForeignItemKind}; +use rustc_public::*; use std::io::Write; use std::ops::ControlFlow; @@ -25,7 +25,7 @@ const CRATE_NAME: &str = "crate_def_ty"; /// Test if we can retrieve type information from different definitions. fn test_def_tys() -> ControlFlow<()> { - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); for item in &items { // Type from crate items. let ty = item.ty(); @@ -37,7 +37,7 @@ fn test_def_tys() -> ControlFlow<()> { } } - let foreign_items = stable_mir::local_crate().foreign_modules(); + let foreign_items = rustc_public::local_crate().foreign_modules(); for item in foreign_items[0].module().items() { // Type from foreign items. let ty = item.ty(); diff --git a/tests/ui-fulldeps/stable-mir/check_defs.rs b/tests/ui-fulldeps/stable-mir/check_defs.rs index 65db50ee3ffba..5e45f19cac89b 100644 --- a/tests/ui-fulldeps/stable-mir/check_defs.rs +++ b/tests/ui-fulldeps/stable-mir/check_defs.rs @@ -13,13 +13,13 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; -extern crate stable_mir; +extern crate rustc_public; use std::assert_matches::assert_matches; use mir::{mono::Instance, TerminatorKind::*}; -use stable_mir::mir::mono::InstanceKind; -use stable_mir::ty::{RigidTy, TyKind, Ty, UintTy}; -use stable_mir::*; +use rustc_public::mir::mono::InstanceKind; +use rustc_public::ty::{RigidTy, TyKind, Ty, UintTy}; +use rustc_public::*; use std::io::Write; use std::ops::ControlFlow; @@ -27,7 +27,7 @@ const CRATE_NAME: &str = "input"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_stable_mir() -> ControlFlow<()> { - let entry = stable_mir::entry_fn().unwrap(); + let entry = rustc_public::entry_fn().unwrap(); let main_fn = Instance::try_from(entry).unwrap(); assert_eq!(main_fn.name(), "main"); assert_eq!(main_fn.trimmed_name(), "main"); diff --git a/tests/ui-fulldeps/stable-mir/check_foreign.rs b/tests/ui-fulldeps/stable-mir/check_foreign.rs index 2947d51b63b6b..9aee067f41b68 100644 --- a/tests/ui-fulldeps/stable-mir/check_foreign.rs +++ b/tests/ui-fulldeps/stable-mir/check_foreign.rs @@ -14,9 +14,9 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; extern crate rustc_span; -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::{ +use rustc_public::{ ty::{Abi, ForeignItemKind}, *, }; diff --git a/tests/ui-fulldeps/stable-mir/check_instance.rs b/tests/ui-fulldeps/stable-mir/check_instance.rs index 9b1e4176531b7..189710760439d 100644 --- a/tests/ui-fulldeps/stable-mir/check_instance.rs +++ b/tests/ui-fulldeps/stable-mir/check_instance.rs @@ -13,21 +13,21 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; -extern crate stable_mir; +extern crate rustc_public; use std::io::Write; use std::ops::ControlFlow; use mir::mono::Instance; use mir::TerminatorKind::*; -use stable_mir::ty::{RigidTy, TyKind}; -use stable_mir::*; +use rustc_public::ty::{RigidTy, TyKind}; +use rustc_public::*; const CRATE_NAME: &str = "input"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_stable_mir() -> ControlFlow<()> { - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); // Get all items and split generic vs monomorphic items. let (generic, mono): (Vec<_>, Vec<_>) = diff --git a/tests/ui-fulldeps/stable-mir/check_intrinsics.rs b/tests/ui-fulldeps/stable-mir/check_intrinsics.rs index 2fce367c7a04e..854ac77956e04 100644 --- a/tests/ui-fulldeps/stable-mir/check_intrinsics.rs +++ b/tests/ui-fulldeps/stable-mir/check_intrinsics.rs @@ -18,12 +18,12 @@ extern crate rustc_hir; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::mir::mono::{Instance, InstanceKind}; -use stable_mir::mir::visit::{Location, MirVisitor}; -use stable_mir::mir::{LocalDecl, Terminator, TerminatorKind}; -use stable_mir::ty::{FnDef, GenericArgs, RigidTy, TyKind}; +use rustc_public::mir::mono::{Instance, InstanceKind}; +use rustc_public::mir::visit::{Location, MirVisitor}; +use rustc_public::mir::{LocalDecl, Terminator, TerminatorKind}; +use rustc_public::ty::{FnDef, GenericArgs, RigidTy, TyKind}; use std::assert_matches::assert_matches; use std::convert::TryFrom; use std::io::Write; @@ -32,7 +32,7 @@ use std::ops::ControlFlow; /// This function tests that we can correctly get type information from binary operations. fn test_intrinsics() -> ControlFlow<()> { // Find items in the local crate. - let main_def = stable_mir::all_local_items()[0]; + let main_def = rustc_public::all_local_items()[0]; let main_instance = Instance::try_from(main_def).unwrap(); let main_body = main_instance.body().unwrap(); let mut visitor = CallsVisitor { locals: main_body.locals(), calls: Default::default() }; diff --git a/tests/ui-fulldeps/stable-mir/check_item_kind.rs b/tests/ui-fulldeps/stable-mir/check_item_kind.rs index 20b9e86ff92e0..58e740bdaef53 100644 --- a/tests/ui-fulldeps/stable-mir/check_item_kind.rs +++ b/tests/ui-fulldeps/stable-mir/check_item_kind.rs @@ -13,9 +13,9 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::*; +use rustc_public::*; use std::io::Write; use std::ops::ControlFlow; @@ -23,7 +23,7 @@ const CRATE_NAME: &str = "input"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_item_kind() -> ControlFlow<()> { - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); assert_eq!(items.len(), 4); // Constructor item. for item in items { diff --git a/tests/ui-fulldeps/stable-mir/check_normalization.rs b/tests/ui-fulldeps/stable-mir/check_normalization.rs index bb5cd49e1b0bf..aa6a257dac6d0 100644 --- a/tests/ui-fulldeps/stable-mir/check_normalization.rs +++ b/tests/ui-fulldeps/stable-mir/check_normalization.rs @@ -12,11 +12,11 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; -extern crate stable_mir; +extern crate rustc_public; use mir::mono::Instance; use ty::{Ty, TyKind, RigidTy}; -use stable_mir::*; +use rustc_public::*; use std::io::Write; use std::ops::ControlFlow; @@ -24,7 +24,7 @@ const CRATE_NAME: &str = "input"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_stable_mir() -> ControlFlow<()> { - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); // Get all items and split generic vs monomorphic items. let instances: Vec<_> = diff --git a/tests/ui-fulldeps/stable-mir/check_trait_queries.rs b/tests/ui-fulldeps/stable-mir/check_trait_queries.rs index 73ba0ea23c934..a6c37883643fa 100644 --- a/tests/ui-fulldeps/stable-mir/check_trait_queries.rs +++ b/tests/ui-fulldeps/stable-mir/check_trait_queries.rs @@ -14,9 +14,9 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::CrateDef; +use rustc_public::CrateDef; use std::collections::HashSet; use std::io::Write; use std::ops::ControlFlow; @@ -25,7 +25,7 @@ const CRATE_NAME: &str = "trait_test"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_traits() -> ControlFlow<()> { - let local_crate = stable_mir::local_crate(); + let local_crate = rustc_public::local_crate(); let local_traits = local_crate.trait_decls(); assert_eq!(local_traits.len(), 1, "Expected `Max` trait, but found {:?}", local_traits); assert_eq!(&local_traits[0].name(), "Max"); @@ -42,14 +42,14 @@ fn test_traits() -> ControlFlow<()> { assert_impl(&impl_names, ""); assert_impl(&impl_names, " for u64>"); - let all_traits = stable_mir::all_trait_decls(); + let all_traits = rustc_public::all_trait_decls(); assert!(all_traits.len() > local_traits.len()); assert!( local_traits.iter().all(|t| all_traits.contains(t)), "Local: {local_traits:#?}, All: {all_traits:#?}" ); - let all_impls = stable_mir::all_trait_impls(); + let all_impls = rustc_public::all_trait_impls(); assert!(all_impls.len() > local_impls.len()); assert!( local_impls.iter().all(|t| all_impls.contains(t)), diff --git a/tests/ui-fulldeps/stable-mir/check_transform.rs b/tests/ui-fulldeps/stable-mir/check_transform.rs index 460f1b9e963c0..3209fcf9ede51 100644 --- a/tests/ui-fulldeps/stable-mir/check_transform.rs +++ b/tests/ui-fulldeps/stable-mir/check_transform.rs @@ -15,13 +15,13 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::mir::alloc::GlobalAlloc; -use stable_mir::mir::mono::Instance; -use stable_mir::mir::{Body, ConstOperand, Operand, Rvalue, StatementKind, TerminatorKind}; -use stable_mir::ty::{ConstantKind, MirConst}; -use stable_mir::{CrateDef, CrateItems, ItemKind}; +use rustc_public::mir::alloc::GlobalAlloc; +use rustc_public::mir::mono::Instance; +use rustc_public::mir::{Body, ConstOperand, Operand, Rvalue, StatementKind, TerminatorKind}; +use rustc_public::ty::{ConstantKind, MirConst}; +use rustc_public::{CrateDef, CrateItems, ItemKind}; use std::convert::TryFrom; use std::io::Write; use std::ops::ControlFlow; @@ -31,7 +31,7 @@ const CRATE_NAME: &str = "input"; /// This function uses the Stable MIR APIs to transform the MIR. fn test_transform() -> ControlFlow<()> { // Find items in the local crate. - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); // Test fn_abi let target_fn = *get_item(&items, (ItemKind::Fn, "dummy")).unwrap(); @@ -109,7 +109,7 @@ fn change_panic_msg(mut body: Body, new_msg: &str) -> Body { fn get_item<'a>( items: &'a CrateItems, item: (ItemKind, &str), -) -> Option<&'a stable_mir::CrateItem> { +) -> Option<&'a rustc_public::CrateItem> { items.iter().find(|crate_item| (item.0 == crate_item.kind()) && crate_item.name() == item.1) } diff --git a/tests/ui-fulldeps/stable-mir/check_ty_fold.rs b/tests/ui-fulldeps/stable-mir/check_ty_fold.rs index 1a21757d03842..07ef0d2bb50b3 100644 --- a/tests/ui-fulldeps/stable-mir/check_ty_fold.rs +++ b/tests/ui-fulldeps/stable-mir/check_ty_fold.rs @@ -15,13 +15,13 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::mir::{ +use rustc_public::mir::{ Body, FieldIdx, MirVisitor, Place, ProjectionElem, visit::{Location, PlaceContext}, }; -use stable_mir::ty::{RigidTy, Ty, TyKind}; +use rustc_public::ty::{RigidTy, Ty, TyKind}; use std::io::Write; use std::ops::ControlFlow; @@ -29,7 +29,7 @@ const CRATE_NAME: &str = "input"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_stable_mir() -> ControlFlow<()> { - let main_fn = stable_mir::entry_fn(); + let main_fn = rustc_public::entry_fn(); let body = main_fn.unwrap().expect_body(); let mut visitor = PlaceVisitor { body: &body, tested: false }; visitor.visit_body(&body); diff --git a/tests/ui-fulldeps/stable-mir/check_variant.rs b/tests/ui-fulldeps/stable-mir/check_variant.rs index 4cff57308f6c7..ebe76bd89d5d4 100644 --- a/tests/ui-fulldeps/stable-mir/check_variant.rs +++ b/tests/ui-fulldeps/stable-mir/check_variant.rs @@ -15,15 +15,15 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; use std::io::Write; use std::ops::ControlFlow; -use stable_mir::CrateItem; -use stable_mir::crate_def::CrateDef; -use stable_mir::mir::{AggregateKind, Rvalue, Statement, StatementKind}; -use stable_mir::ty::{IntTy, RigidTy, Ty}; +use rustc_public::CrateItem; +use rustc_public::crate_def::CrateDef; +use rustc_public::mir::{AggregateKind, Rvalue, Statement, StatementKind}; +use rustc_public::ty::{IntTy, RigidTy, Ty}; const CRATE_NAME: &str = "crate_variant_ty"; @@ -97,7 +97,7 @@ fn check_adt_poly2() { } fn get_fn(name: &str) -> CrateItem { - stable_mir::all_local_items().into_iter().find(|it| it.name().eq(name)).unwrap() + rustc_public::all_local_items().into_iter().find(|it| it.name().eq(name)).unwrap() } fn check_statement_is_aggregate_assign( diff --git a/tests/ui-fulldeps/stable-mir/closure-generic-body.rs b/tests/ui-fulldeps/stable-mir/closure-generic-body.rs index 6b3447e583973..e5f910fbda115 100644 --- a/tests/ui-fulldeps/stable-mir/closure-generic-body.rs +++ b/tests/ui-fulldeps/stable-mir/closure-generic-body.rs @@ -14,18 +14,18 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; use std::io::Write; use std::ops::ControlFlow; -use stable_mir::mir::{Body, ConstOperand, Operand, TerminatorKind}; -use stable_mir::ty::{FnDef, RigidTy, TyKind}; +use rustc_public::mir::{Body, ConstOperand, Operand, TerminatorKind}; +use rustc_public::ty::{FnDef, RigidTy, TyKind}; const CRATE_NAME: &str = "crate_closure_body"; fn test_closure_body() -> ControlFlow<()> { - let crate_items = stable_mir::all_local_items(); + let crate_items = rustc_public::all_local_items(); for item in crate_items { let item_ty = item.ty(); match &item_ty.kind() { diff --git a/tests/ui-fulldeps/stable-mir/closure_body.rs b/tests/ui-fulldeps/stable-mir/closure_body.rs index a1c97e7549b8a..f5f9f23ad126d 100644 --- a/tests/ui-fulldeps/stable-mir/closure_body.rs +++ b/tests/ui-fulldeps/stable-mir/closure_body.rs @@ -14,18 +14,18 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; use std::io::Write; use std::ops::ControlFlow; -use stable_mir::mir::{Body, ConstOperand, Operand, TerminatorKind}; -use stable_mir::ty::{FnDef, RigidTy, TyKind}; +use rustc_public::mir::{Body, ConstOperand, Operand, TerminatorKind}; +use rustc_public::ty::{FnDef, RigidTy, TyKind}; const CRATE_NAME: &str = "crate_closure_body"; fn test_closure_body() -> ControlFlow<()> { - let crate_items = stable_mir::all_local_items(); + let crate_items = rustc_public::all_local_items(); for item in crate_items { let item_ty = item.ty(); match &item_ty.kind() { diff --git a/tests/ui-fulldeps/stable-mir/compilation-result.rs b/tests/ui-fulldeps/stable-mir/compilation-result.rs index d577de48c5586..ed013375c7135 100644 --- a/tests/ui-fulldeps/stable-mir/compilation-result.rs +++ b/tests/ui-fulldeps/stable-mir/compilation-result.rs @@ -14,7 +14,7 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; use std::io::Write; @@ -40,7 +40,7 @@ fn test_continue(args: &[String]) { fn test_break(args: &[String]) { let result = run!(args, || ControlFlow::Break::(false)); - assert_eq!(result, Err(stable_mir::CompilerError::Interrupted(false))); + assert_eq!(result, Err(rustc_public::CompilerError::Interrupted(false))); } #[allow(unreachable_code)] @@ -48,7 +48,7 @@ fn test_skipped(args: &[String]) { let mut args = args.to_vec(); args.push("--version".to_string()); let result = run!(&args, || unreachable!() as ControlFlow<()>); - assert_eq!(result, Err(stable_mir::CompilerError::Skipped)); + assert_eq!(result, Err(rustc_public::CompilerError::Skipped)); } #[allow(unreachable_code)] @@ -56,7 +56,7 @@ fn test_failed(args: &[String]) { let mut args = args.to_vec(); args.push("--cfg=broken".to_string()); let result = run!(&args, || unreachable!() as ControlFlow<()>); - assert_eq!(result, Err(stable_mir::CompilerError::Failed)); + assert_eq!(result, Err(rustc_public::CompilerError::Failed)); } /// Test that we are able to pass a closure and set the return according to the captured value. diff --git a/tests/ui-fulldeps/stable-mir/crate-info.rs b/tests/ui-fulldeps/stable-mir/crate-info.rs index fd7c2032b6d9c..4f46dff9b8204 100644 --- a/tests/ui-fulldeps/stable-mir/crate-info.rs +++ b/tests/ui-fulldeps/stable-mir/crate-info.rs @@ -15,13 +15,13 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; use rustc_hir::def::DefKind; -use stable_mir::ItemKind; -use stable_mir::crate_def::CrateDef; -use stable_mir::mir::mono::Instance; -use stable_mir::ty::{RigidTy, TyKind}; +use rustc_public::ItemKind; +use rustc_public::crate_def::CrateDef; +use rustc_public::mir::mono::Instance; +use rustc_public::ty::{RigidTy, TyKind}; use std::assert_matches::assert_matches; use std::io::Write; use std::ops::ControlFlow; @@ -30,18 +30,18 @@ const CRATE_NAME: &str = "input"; /// This function uses the Stable MIR APIs to get information about the test crate. fn test_stable_mir() -> ControlFlow<()> { - // Get the local crate using stable_mir API. - let local = stable_mir::local_crate(); + // Get the local crate using rustc_public API. + let local = rustc_public::local_crate(); assert_eq!(&local.name, CRATE_NAME); - assert_eq!(stable_mir::entry_fn(), None); + assert_eq!(rustc_public::entry_fn(), None); // Find items in the local crate. - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); assert!(get_item(&items, (DefKind::Fn, "foo::bar")).is_some()); // Find the `std` crate and assert that there is only one of it. - assert!(stable_mir::find_crates("std").len() == 1); + assert!(rustc_public::find_crates("std").len() == 1); let bar = get_item(&items, (DefKind::Fn, "bar")).unwrap(); let body = bar.expect_body(); @@ -50,11 +50,11 @@ fn test_stable_mir() -> ControlFlow<()> { let block = &body.blocks[0]; assert_eq!(block.statements.len(), 1); match &block.statements[0].kind { - stable_mir::mir::StatementKind::Assign(..) => {} + rustc_public::mir::StatementKind::Assign(..) => {} other => panic!("{other:?}"), } match &block.terminator.kind { - stable_mir::mir::TerminatorKind::Return => {} + rustc_public::mir::TerminatorKind::Return => {} other => panic!("{other:?}"), } @@ -64,7 +64,7 @@ fn test_stable_mir() -> ControlFlow<()> { assert_eq!(body.blocks.len(), 4); let block = &body.blocks[0]; match &block.terminator.kind { - stable_mir::mir::TerminatorKind::Call { .. } => {} + rustc_public::mir::TerminatorKind::Call { .. } => {} other => panic!("{other:?}"), } @@ -73,28 +73,32 @@ fn test_stable_mir() -> ControlFlow<()> { assert_eq!(body.locals().len(), 6); assert_matches!( body.locals()[0].ty.kind(), - stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Bool) + rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool) ); assert_matches!( body.locals()[1].ty.kind(), - stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Bool) + rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool) ); assert_matches!( body.locals()[2].ty.kind(), - stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Char) + rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Char) ); assert_matches!( body.locals()[3].ty.kind(), - stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Int(stable_mir::ty::IntTy::I32)) + rustc_public::ty::TyKind::RigidTy( + rustc_public::ty::RigidTy::Int(rustc_public::ty::IntTy::I32) + ) ); assert_matches!( body.locals()[4].ty.kind(), - stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Uint(stable_mir::ty::UintTy::U64)) + rustc_public::ty::TyKind::RigidTy( + rustc_public::ty::RigidTy::Uint(rustc_public::ty::UintTy::U64) + ) ); assert_matches!( body.locals()[5].ty.kind(), - stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Float( - stable_mir::ty::FloatTy::F64 + rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Float( + rustc_public::ty::FloatTy::F64 )) ); @@ -103,7 +107,7 @@ fn test_stable_mir() -> ControlFlow<()> { assert_eq!(body.blocks.len(), 2); let block = &body.blocks[0]; match &block.terminator.kind { - stable_mir::mir::TerminatorKind::Drop { .. } => {} + rustc_public::mir::TerminatorKind::Drop { .. } => {} other => panic!("{other:?}"), } @@ -112,7 +116,7 @@ fn test_stable_mir() -> ControlFlow<()> { assert_eq!(body.blocks.len(), 2); let block = &body.blocks[0]; match &block.terminator.kind { - stable_mir::mir::TerminatorKind::Assert { .. } => {} + rustc_public::mir::TerminatorKind::Assert { .. } => {} other => panic!("{other:?}"), } @@ -120,7 +124,7 @@ fn test_stable_mir() -> ControlFlow<()> { let instance = Instance::try_from(monomorphic.clone()).unwrap(); for block in instance.body().unwrap().blocks { match &block.terminator.kind { - stable_mir::mir::TerminatorKind::Call { func, .. } => { + rustc_public::mir::TerminatorKind::Call { func, .. } => { let TyKind::RigidTy(ty) = func.ty(&body.locals()).unwrap().kind() else { unreachable!() }; @@ -131,7 +135,7 @@ fn test_stable_mir() -> ControlFlow<()> { other => panic!("{other:?}"), } } - stable_mir::mir::TerminatorKind::Return => {} + rustc_public::mir::TerminatorKind::Return => {} other => panic!("{other:?}"), } } @@ -145,22 +149,26 @@ fn test_stable_mir() -> ControlFlow<()> { assert_eq!(body.locals().len(), 4); assert_matches!( body.ret_local().ty.kind(), - stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Char) + rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Char) ); assert_eq!(body.arg_locals().len(), 2); assert_matches!( body.arg_locals()[0].ty.kind(), - stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Int(stable_mir::ty::IntTy::I32)) + rustc_public::ty::TyKind::RigidTy( + rustc_public::ty::RigidTy::Int(rustc_public::ty::IntTy::I32) + ) ); assert_matches!( body.arg_locals()[1].ty.kind(), - stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Uint(stable_mir::ty::UintTy::U64)) + rustc_public::ty::TyKind::RigidTy( + rustc_public::ty::RigidTy::Uint(rustc_public::ty::UintTy::U64) + ) ); assert_eq!(body.inner_locals().len(), 1); // If conditions have an extra inner local to hold their results assert_matches!( body.inner_locals()[0].ty.kind(), - stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Bool) + rustc_public::ty::TyKind::RigidTy(rustc_public::ty::RigidTy::Bool) ); ControlFlow::Continue(()) @@ -168,9 +176,9 @@ fn test_stable_mir() -> ControlFlow<()> { // Use internal API to find a function in a crate. fn get_item<'a>( - items: &'a stable_mir::CrateItems, + items: &'a rustc_public::CrateItems, item: (DefKind, &str), -) -> Option<&'a stable_mir::CrateItem> { +) -> Option<&'a rustc_public::CrateItem> { items.iter().find(|crate_item| { matches!( (item.0, crate_item.kind()), diff --git a/tests/ui-fulldeps/stable-mir/projections.rs b/tests/ui-fulldeps/stable-mir/projections.rs index f8104287700ba..3b360cd2fcfff 100644 --- a/tests/ui-fulldeps/stable-mir/projections.rs +++ b/tests/ui-fulldeps/stable-mir/projections.rs @@ -15,12 +15,12 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::ItemKind; -use stable_mir::crate_def::CrateDef; -use stable_mir::mir::{ProjectionElem, Rvalue, StatementKind}; -use stable_mir::ty::{RigidTy, TyKind, UintTy}; +use rustc_public::ItemKind; +use rustc_public::crate_def::CrateDef; +use rustc_public::mir::{ProjectionElem, Rvalue, StatementKind}; +use rustc_public::ty::{RigidTy, TyKind, UintTy}; use std::assert_matches::assert_matches; use std::io::Write; use std::ops::ControlFlow; @@ -29,15 +29,15 @@ const CRATE_NAME: &str = "input"; /// Tests projections within Place objects fn test_place_projections() -> ControlFlow<()> { - let items = stable_mir::all_local_items(); + let items = rustc_public::all_local_items(); let body = get_item(&items, (ItemKind::Fn, "projections")).unwrap().expect_body(); assert_eq!(body.blocks.len(), 4); // The first statement assigns `&s.c` to a local. The projections include a deref for `s`, since // `s` is passed as a reference argument, and a field access for field `c`. match &body.blocks[0].statements[0].kind { StatementKind::Assign( - place @ stable_mir::mir::Place { local: _, projection: local_proj }, - Rvalue::Ref(_, _, stable_mir::mir::Place { local: _, projection: r_proj }), + place @ rustc_public::mir::Place { local: _, projection: local_proj }, + Rvalue::Ref(_, _, rustc_public::mir::Place { local: _, projection: r_proj }), ) => { // We can't match on vecs, only on slices. Comparing statements for equality wouldn't be // any easier since we'd then have to add in the expected local and region values @@ -48,7 +48,7 @@ fn test_place_projections() -> ControlFlow<()> { [ProjectionElem::Deref, ProjectionElem::Field(2, ty)] => { assert_matches!( ty.kind(), - TyKind::RigidTy(RigidTy::Uint(stable_mir::ty::UintTy::U8)) + TyKind::RigidTy(RigidTy::Uint(rustc_public::ty::UintTy::U8)) ); let ty = place.ty(body.locals()).unwrap(); assert_matches!(ty.kind().rigid(), Some(RigidTy::Ref(..))); @@ -70,8 +70,8 @@ fn test_place_projections() -> ControlFlow<()> { // since `slice` is a reference, and an index. match &body.blocks[2].statements[0].kind { StatementKind::Assign( - place @ stable_mir::mir::Place { local: _, projection: local_proj }, - Rvalue::Use(stable_mir::mir::Operand::Copy(stable_mir::mir::Place { + place @ rustc_public::mir::Place { local: _, projection: local_proj }, + Rvalue::Use(rustc_public::mir::Operand::Copy(rustc_public::mir::Place { local: _, projection: r_proj, })), @@ -93,18 +93,18 @@ fn test_place_projections() -> ControlFlow<()> { // The first terminator gets a slice of an array via the Index operation. Specifically it // performs `&vals[1..3]`. There are no projections in this case, the arguments are just locals. match &body.blocks[0].terminator.kind { - stable_mir::mir::TerminatorKind::Call { args, .. } => + rustc_public::mir::TerminatorKind::Call { args, .. } => // We can't match on vecs, only on slices. Comparing for equality wouldn't be any easier // since we'd then have to add in the expected local values instead of matching on // wildcards. { match &args[..] { [ - stable_mir::mir::Operand::Move(stable_mir::mir::Place { + rustc_public::mir::Operand::Move(rustc_public::mir::Place { local: _, projection: arg1_proj, }), - stable_mir::mir::Operand::Move(stable_mir::mir::Place { + rustc_public::mir::Operand::Move(rustc_public::mir::Place { local: _, projection: arg2_proj, }), @@ -133,9 +133,9 @@ fn test_place_projections() -> ControlFlow<()> { // Use internal API to find a function in a crate. fn get_item<'a>( - items: &'a stable_mir::CrateItems, + items: &'a rustc_public::CrateItems, item: (ItemKind, &str), -) -> Option<&'a stable_mir::CrateItem> { +) -> Option<&'a rustc_public::CrateItem> { items.iter().find(|crate_item| crate_item.kind() == item.0 && crate_item.name() == item.1) } diff --git a/tests/ui-fulldeps/stable-mir/smir_internal.rs b/tests/ui-fulldeps/stable-mir/smir_internal.rs index 287f4353d51c0..dd70cfe5f5e6e 100644 --- a/tests/ui-fulldeps/stable-mir/smir_internal.rs +++ b/tests/ui-fulldeps/stable-mir/smir_internal.rs @@ -14,17 +14,17 @@ extern crate rustc_driver; extern crate rustc_interface; extern crate rustc_middle; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; use rustc_middle::ty::TyCtxt; -use stable_mir::rustc_internal; +use rustc_public::rustc_internal; use std::io::Write; use std::ops::ControlFlow; const CRATE_NAME: &str = "input"; fn test_translation(tcx: TyCtxt<'_>) -> ControlFlow<()> { - let main_fn = stable_mir::entry_fn().unwrap(); + let main_fn = rustc_public::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); diff --git a/tests/ui-fulldeps/stable-mir/smir_serde.rs b/tests/ui-fulldeps/stable-mir/smir_serde.rs index c2f00e56c2cef..31642c6cb94c0 100644 --- a/tests/ui-fulldeps/stable-mir/smir_serde.rs +++ b/tests/ui-fulldeps/stable-mir/smir_serde.rs @@ -16,11 +16,11 @@ extern crate rustc_middle; extern crate serde; extern crate serde_json; #[macro_use] -extern crate stable_mir; +extern crate rustc_public; use rustc_middle::ty::TyCtxt; use serde_json::to_string; -use stable_mir::mir::Body; +use rustc_public::mir::Body; use std::io::{BufWriter, Write}; use std::ops::ControlFlow; @@ -29,9 +29,9 @@ const CRATE_NAME: &str = "input"; fn serialize_to_json(_tcx: TyCtxt<'_>) -> ControlFlow<()> { let path = "output.json"; let mut writer = BufWriter::new(std::fs::File::create(path).expect("Failed to create path")); - let local_crate = stable_mir::local_crate(); + let local_crate = rustc_public::local_crate(); let items: Vec = - stable_mir::all_local_items().iter().map(|item| item.expect_body()).collect(); + rustc_public::all_local_items().iter().map(|item| item.expect_body()).collect(); let crate_data = (local_crate.name, items); writer .write_all(to_string(&crate_data).expect("serde_json failed").as_bytes()) diff --git a/tests/ui-fulldeps/stable-mir/smir_visitor.rs b/tests/ui-fulldeps/stable-mir/smir_visitor.rs index 46f85a992efd1..66787e2927bde 100644 --- a/tests/ui-fulldeps/stable-mir/smir_visitor.rs +++ b/tests/ui-fulldeps/stable-mir/smir_visitor.rs @@ -13,11 +13,11 @@ extern crate rustc_middle; extern crate rustc_driver; extern crate rustc_interface; -extern crate stable_mir; +extern crate rustc_public; -use stable_mir::mir::MirVisitor; -use stable_mir::mir::MutMirVisitor; -use stable_mir::*; +use rustc_public::mir::MirVisitor; +use rustc_public::mir::MutMirVisitor; +use rustc_public::*; use std::collections::HashSet; use std::io::Write; use std::ops::ControlFlow; @@ -25,7 +25,7 @@ use std::ops::ControlFlow; const CRATE_NAME: &str = "input"; fn test_visitor() -> ControlFlow<()> { - let main_fn = stable_mir::entry_fn(); + let main_fn = rustc_public::entry_fn(); let main_body = main_fn.unwrap().expect_body(); let main_visitor = TestVisitor::collect(&main_body); assert!(main_visitor.ret_val.is_some()); @@ -99,7 +99,7 @@ impl<'a> mir::MirVisitor for TestVisitor<'a> { } fn test_mut_visitor() -> ControlFlow<()> { - let main_fn = stable_mir::entry_fn(); + let main_fn = rustc_public::entry_fn(); let mut main_body = main_fn.unwrap().expect_body(); let locals = main_body.locals().to_vec(); let mut main_visitor = TestMutVisitor::collect(locals); diff --git a/triagebot.toml b/triagebot.toml index 9f8ea2dad52fe..6c0d0b379ea39 100644 --- a/triagebot.toml +++ b/triagebot.toml @@ -1052,8 +1052,8 @@ cc = ["@davidtwco", "@compiler-errors", "@TaKO8Ki"] message = "`rustc_macros::diagnostics` was changed" cc = ["@davidtwco", "@compiler-errors", "@TaKO8Ki"] -[mentions."compiler/stable_mir"] -message = "This PR changes Stable MIR" +[mentions."compiler/rustc_public"] +message = "This PR changes rustc_public" cc = ["@oli-obk", "@celinval", "@ouz-a"] [mentions."compiler/rustc_target/src/spec"] @@ -1447,7 +1447,7 @@ dep-bumps = [ "/compiler/rustc_const_eval/src/interpret" = ["compiler", "mir"] "/compiler/rustc_mir_build/src/builder" = ["compiler", "mir"] "/compiler/rustc_mir_transform" = ["compiler", "mir", "mir-opt"] -"/compiler/rustc_smir" = ["project-stable-mir"] +"/compiler/rustc_public_shim" = ["project-stable-mir"] "/compiler/rustc_parse" = ["compiler", "parser"] "/compiler/rustc_parse/src/lexer" = ["compiler", "lexer"] "/compiler/rustc_query_impl" = ["compiler", "query-system"] @@ -1457,7 +1457,7 @@ dep-bumps = [ "/compiler/rustc_trait_selection" = ["compiler", "types"] "/compiler/rustc_traits" = ["compiler", "types"] "/compiler/rustc_type_ir" = ["compiler", "types"] -"/compiler/stable_mir" = ["project-stable-mir"] +"/compiler/rustc_public" = ["project-stable-mir"] "/library/alloc" = ["libs"] "/library/core" = ["libs", "@scottmcm"] "/library/panic_abort" = ["libs"]