rust-lang · bors · Oct 23, 2023 · Oct 17, 2023 · Oct 20, 2023
diff --git a/Cargo.lock b/Cargo.lock
@@ -4520,9 4520,7 @@ name = "rustc_smir"
 version = "0.0.0"
 dependencies = [
  "rustc_data_structures",
- "rustc_driver",
  "rustc_hir",
- "rustc_interface",
  "rustc_middle",
  "rustc_span",
  "rustc_target",

diff --git a/compiler/rustc_smir/Cargo.toml b/compiler/rustc_smir/Cargo.toml
@@ -5,9 5,7 @@ edition = "2021"
 
 [dependencies]
 rustc_data_structures = { path = "../rustc_data_structures" }
-rustc_driver = { path = "../rustc_driver" }
 rustc_hir = { path = "../rustc_hir" }
-rustc_interface = { path = "../rustc_interface" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }

diff --git a/compiler/rustc_smir/src/rustc_internal/mod.rs b/compiler/rustc_smir/src/rustc_internal/mod.rs
@@ -3,22 3,18 @@
 //! For that, we define APIs that will temporarily be public to 3P that exposes rustc internal APIs
 //! until stable MIR is complete.
 
-use crate::rustc_internal;
 use crate::rustc_smir::Tables;
 use rustc_data_structures::fx;
 use rustc_data_structures::fx::FxIndexMap;
-use rustc_driver::{Callbacks, Compilation, RunCompiler};
-use rustc_interface::{interface, Queries};
 use rustc_middle::mir::interpret::AllocId;
 use rustc_middle::ty;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::def_id::{CrateNum, DefId};
 use rustc_span::Span;
 use stable_mir::ty::IndexedVal;
-use stable_mir::CompilerError;
 use std::fmt::Debug;
 use std::hash::Hash;
-use std::ops::{ControlFlow, Index};
 use std::ops::Index;
 
 mod internal;
 
@@ -143,63 139,81 @@ pub fn run(tcx: TyCtxt<'_>, f: impl FnOnce()) {
  );
 }
 
-pub struct StableMir<B = (), C = ()>
-where
- B: Send,
- C: Send,
-{
- args: Vec<String>,
- callback: fn(TyCtxt<'_>) -> ControlFlow<B, C>,
- result: Option<ControlFlow<B, C>>,
-}
 #[macro_export]
 macro_rules! run {
  ($args:expr, $callback:expr) => {
  run!($args, tcx, $callback)
  };
  ($args:expr, $tcx:ident, $callback:expr) => {{
  use rustc_driver::{Callbacks, Compilation, RunCompiler};
  use rustc_interface::{interface, Queries};
  use stable_mir::CompilerError;
  use std::ops::ControlFlow;
 
  pub struct StableMir<B = (), C = ()>
  where
  B: Send,
  C: Send,
  {
  args: Vec<String>,
  callback: fn(TyCtxt<'_>) -> ControlFlow<B, C>,
  result: Option<ControlFlow<B, C>>,
  }
 
-impl<B, C> StableMir<B, C>
-where
- B: Send,
- C: Send,
-{
- /// Creates a new `StableMir` instance, with given test_function and arguments.
- pub fn new(args: Vec<String>, callback: fn(TyCtxt<'_>) -> ControlFlow<B, C>) -> Self {
- StableMir { args, callback, result: None }
- }
-
- /// Runs the compiler against given target and tests it with `test_function`
- pub fn run(&mut self) -> Result<C, CompilerError<B>> {
- let compiler_result =
- rustc_driver::catch_fatal_errors(|| RunCompiler::new(&self.args.clone(), self).run());
- match (compiler_result, self.result.take()) {
- (Ok(Ok(())), Some(ControlFlow::Continue(value))) => Ok(value),
- (Ok(Ok(())), Some(ControlFlow::Break(value))) => Err(CompilerError::Interrupted(value)),
- (Ok(Ok(_)), None) => Err(CompilerError::Skipped),
- (Ok(Err(_)), _) => Err(CompilerError::CompilationFailed),
- (Err(_), _) => Err(CompilerError::ICE),
  impl<B, C> StableMir<B, C>
  where
  B: Send,
  C: Send,
  {
  /// Creates a new `StableMir` instance, with given test_function and arguments.
  pub fn new(args: Vec<String>, callback: fn(TyCtxt<'_>) -> ControlFlow<B, C>) -> Self {
  StableMir { args, callback, result: None }
  }
 
  /// Runs the compiler against given target and tests it with `test_function`
  pub fn run(&mut self) -> Result<C, CompilerError<B>> {
  let compiler_result = rustc_driver::catch_fatal_errors(|| {
  RunCompiler::new(&self.args.clone(), self).run()
  });
  match (compiler_result, self.result.take()) {
  (Ok(Ok(())), Some(ControlFlow::Continue(value))) => Ok(value),
  (Ok(Ok(())), Some(ControlFlow::Break(value))) => {
  Err(CompilerError::Interrupted(value))
  }
  (Ok(Ok(_)), None) => Err(CompilerError::Skipped),
  (Ok(Err(_)), _) => Err(CompilerError::CompilationFailed),
  (Err(_), _) => Err(CompilerError::ICE),
  }
  }
  }
- }
-}
 
-impl<B, C> Callbacks for StableMir<B, C>
-where
- B: Send,
- C: Send,
-{
- /// Called after analysis. Return value instructs the compiler whether to
- /// continue the compilation afterwards (defaults to `Compilation::Continue`)
- fn after_analysis<'tcx>(
- &mut self,
- _compiler: &interface::Compiler,
- queries: &'tcx Queries<'tcx>,
- ) -> Compilation {
- queries.global_ctxt().unwrap().enter(|tcx| {
- rustc_internal::run(tcx, || {
- self.result = Some((self.callback)(tcx));
- });
- if self.result.as_ref().is_some_and(|val| val.is_continue()) {
- Compilation::Continue
- } else {
- Compilation::Stop
  impl<B, C> Callbacks for StableMir<B, C>
  where
  B: Send,
  C: Send,
  {
  /// Called after analysis. Return value instructs the compiler whether to
  /// continue the compilation afterwards (defaults to `Compilation::Continue`)
  fn after_analysis<'tcx>(
  &mut self,
  _compiler: &interface::Compiler,
  queries: &'tcx Queries<'tcx>,
  ) -> Compilation {
  queries.global_ctxt().unwrap().enter(|tcx| {
  rustc_internal::run(tcx, || {
  self.result = Some((self.callback)(tcx));
  });
  if self.result.as_ref().is_some_and(|val| val.is_continue()) {
  Compilation::Continue
  } else {
  Compilation::Stop
  }
  })
  }
- })
- }
  }
 
  StableMir::new($args, |$tcx| $callback).run()
  }};
 }
 
 /// Simmilar to rustc's `FxIndexMap`, `IndexMap` with extra

diff --git a/tests/ui-fulldeps/stable-mir/check_instance.rs b/tests/ui-fulldeps/stable-mir/check_instance.rs
@@ -4,15 4,19 @@
 // ignore-stage1
 // ignore-cross-compile
 // ignore-remote
 // ignore-windows-gnu mingw has troubles with linking https://github.com/rust-lang/rust/pull/116837
 // edition: 2021
 
 #![feature(rustc_private)]
 #![feature(assert_matches)]
 #![feature(control_flow_enum)]
 
 extern crate rustc_middle;
 #[macro_use]
 extern crate rustc_smir;
 extern crate stable_mir;
 extern crate rustc_driver;
 extern crate rustc_interface;
 
 use rustc_middle::ty::TyCtxt;
 use mir::{mono::Instance, TerminatorKind::*};
@@ -82,7 86,7 @@ fn main() {
  CRATE_NAME.to_string(),
  path.to_string(),
  ];
- rustc_internal::StableMir::new(args, test_stable_mir).run().unwrap();
  run!(args, tcx, test_stable_mir(tcx)).unwrap();
 }
 
 fn generate_input(path: &str) -> std::io::Result<()> {

diff --git a/tests/ui-fulldeps/stable-mir/compilation-result.rs b/tests/ui-fulldeps/stable-mir/compilation-result.rs
@@ -4,19 4,22 @@
 // ignore-stage1
 // ignore-cross-compile
 // ignore-remote
 // ignore-windows-gnu mingw has troubles with linking https://github.com/rust-lang/rust/pull/116837
 // edition: 2021
 
 #![feature(rustc_private)]
 #![feature(assert_matches)]
 
 extern crate rustc_middle;
 #[macro_use]
 extern crate rustc_smir;
 extern crate rustc_driver;
 extern crate rustc_interface;
 extern crate stable_mir;
 
 use rustc_middle::ty::TyCtxt;
 use rustc_smir::rustc_internal;
 use std::io::Write;
-use std::ops::ControlFlow;
 
 /// This test will generate and analyze a dummy crate using the stable mir.
 /// For that, it will first write the dummy crate into a file.
@@ -33,28 36,26 @@ fn main() {
 }
 
 fn test_continue(args: Vec<String>) {
- let continue_fn = |_: TyCtxt| ControlFlow::Continue::<(), bool>(true);
- let result = rustc_internal::StableMir::new(args, continue_fn).run();
  let result = run!(args, ControlFlow::Continue::<(), bool>(true));
  assert_eq!(result, Ok(true));
 }
 
 fn test_break(args: Vec<String>) {
- let continue_fn = |_: TyCtxt| ControlFlow::Break::<bool, i32>(false);
- let result = rustc_internal::StableMir::new(args, continue_fn).run();
  let result = run!(args, ControlFlow::Break::<bool, i32>(false));
  assert_eq!(result, Err(stable_mir::CompilerError::Interrupted(false)));
 }
 
 #[allow(unreachable_code)]
 fn test_skipped(mut args: Vec<String>) {
  args.push("--version".to_string());
- let unreach_fn = |_: TyCtxt| -> ControlFlow<()> { unreachable!() };
- let result = rustc_internal::StableMir::new(args, unreach_fn).run();
  let result = run!(args, unreachable!() as ControlFlow<()>);
  assert_eq!(result, Err(stable_mir::CompilerError::Skipped));
 }
 
 #[allow(unreachable_code)]
 fn test_failed(mut args: Vec<String>) {
  args.push("--cfg=broken".to_string());
- let unreach_fn = |_: TyCtxt| -> ControlFlow<()> { unreachable!() };
- let result = rustc_internal::StableMir::new(args, unreach_fn).run();
  let result = run!(args, unreachable!() as ControlFlow<()>);
  assert_eq!(result, Err(stable_mir::CompilerError::CompilationFailed));
 }
 

diff --git a/tests/ui-fulldeps/stable-mir/crate-info.rs b/tests/ui-fulldeps/stable-mir/crate-info.rs
@@ -4,6 4,7 @@
 // ignore-stage1
 // ignore-cross-compile
 // ignore-remote
 // ignore-windows-gnu mingw has troubles with linking https://github.com/rust-lang/rust/pull/116837
 // edition: 2021
 
 #![feature(rustc_private)]
@@ -12,7 13,10 @@
 
 extern crate rustc_hir;
 extern crate rustc_middle;
 #[macro_use]
 extern crate rustc_smir;
 extern crate rustc_driver;
 extern crate rustc_interface;
 extern crate stable_mir;
 
 use rustc_hir::def::DefKind;
@@ -185,7 189,7 @@ fn main() {
  CRATE_NAME.to_string(),
  path.to_string(),
  ];
- rustc_internal::StableMir::new(args, test_stable_mir).run().unwrap();
  run!(args, tcx, test_stable_mir(tcx)).unwrap();
 }
 
 fn generate_input(path: &str) -> std::io::Result<()> {