use RustcPublic instead of StableMir

compiler/rustc_public/src/rustc_internal/mod.rs

@@ -191,7 +191,7 @@ macro_rules! run_driver {
         use rustc_public::CompilerError;
         use std::ops::ControlFlow;
 
-        pub struct StableMir<B = (), C = (), F = fn($($crate::optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C>>
+        pub struct RustcPublic<B = (), C = (), F = fn($($crate::optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C>>
         where
             B: Send,
             C: Send,
@@ -201,15 +201,15 @@ pub struct StableMir<B = (), C = (), F = fn($($crate::optional!($with_tcx TyCtxt
             result: Option<ControlFlow<B, C>>,
         }
 
-        impl<B, C, F> StableMir<B, C, F>
+        impl<B, C, F> RustcPublic<B, C, F>
         where
             B: Send,
             C: Send,
             F: FnOnce($($crate::optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C> + Send,
         {
-            /// Creates a new `StableMir` instance, with given test_function and arguments.
+            /// Creates a new `RustcPublic` instance, with given test_function and arguments.
             pub fn new(callback: F) -> Self {
-                StableMir { callback: Some(callback), result: None }
+                RustcPublic { callback: Some(callback), result: None }
             }
 
             /// Runs the compiler against given target and tests it with `test_function`
@@ -236,7 +236,7 @@ pub fn run(&mut self, args: &[String]) -> Result<C, CompilerError<B>> {
             }
         }
 
-        impl<B, C, F> Callbacks for StableMir<B, C, F>
+        impl<B, C, F> Callbacks for RustcPublic<B, C, F>
         where
             B: Send,
             C: Send,
@@ -265,6 +265,6 @@ fn after_analysis<'tcx>(
             }
         }
 
-        StableMir::new($callback).run($args)
+        RustcPublic::new($callback).run($args)
     }};
 }

tests/ui-fulldeps/rustc_public/check_abi.rs

@@ -167,7 +167,7 @@ fn visit_ty(&mut self, ty: &Ty, _location: rustc_public::mir::visit::Location) {
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "alloc_input.rs";

tests/ui-fulldeps/rustc_public/check_allocation.rs

@@ -202,7 +202,7 @@ fn get_item<'a>(
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "alloc_input.rs";

tests/ui-fulldeps/rustc_public/check_attribute.rs

@@ -52,7 +52,7 @@ fn get_item<'a>(
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "attribute_input.rs";

tests/ui-fulldeps/rustc_public/check_binop.rs

@@ -76,7 +76,7 @@ fn visit_terminator(&mut self, term: &Terminator, _loc: Location) {
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "binop_input.rs";

tests/ui-fulldeps/rustc_public/check_crate_defs.rs

@@ -79,7 +79,7 @@ fn contains<T: CrateDef + std::fmt::Debug>(items: &[T], expected: &[&str]) {
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "crate_definitions.rs";

tests/ui-fulldeps/rustc_public/check_def_ty.rs

@@ -70,7 +70,7 @@ fn check_fn_def(ty: Ty) {
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "defs_ty_input.rs";

tests/ui-fulldeps/rustc_public/check_defs.rs

@@ -106,7 +106,7 @@ fn get_instances(body: mir::Body) -> Vec<Instance> {
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "defs_input.rs";

tests/ui-fulldeps/rustc_public/check_foreign.rs

@@ -52,7 +52,7 @@ fn test_foreign() -> 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "foreign_input.rs";

tests/ui-fulldeps/rustc_public/check_instance.rs

@@ -81,7 +81,7 @@ fn test_body(body: mir::Body) {
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "instance_input.rs";

tests/ui-fulldeps/rustc_public/check_intrinsics.rs

@@ -110,7 +110,7 @@ fn visit_terminator(&mut self, term: &Terminator, _loc: Location) {
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "binop_input.rs";

tests/ui-fulldeps/rustc_public/check_item_kind.rs

@@ -41,7 +41,7 @@ fn test_item_kind() -> 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "item_kind_input.rs";

tests/ui-fulldeps/rustc_public/check_normalization.rs

@@ -55,7 +55,7 @@ fn check_ty(ty: Ty) {
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "normalization_input.rs";

tests/ui-fulldeps/rustc_public/check_trait_queries.rs

@@ -67,7 +67,7 @@ fn assert_impl(impl_names: &HashSet<String>, target: &str) {
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "trait_queries.rs";

tests/ui-fulldeps/rustc_public/check_transform.rs

@@ -115,7 +115,7 @@ fn get_item<'a>(
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "transform_input.rs";

tests/ui-fulldeps/rustc_public/check_ty_fold.rs

@@ -73,7 +73,7 @@ fn visit_place(&mut self, place: &Place, _ptx: PlaceContext, _loc: Location) {
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "ty_fold_input.rs";

tests/ui-fulldeps/rustc_public/check_variant.rs

@@ -120,7 +120,7 @@ fn check_statement_is_aggregate_assign(
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "defs_ty_input.rs";

tests/ui-fulldeps/rustc_public/compilation-result.rs

@@ -20,7 +20,7 @@
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "input_compilation_result_test.rs";

tests/ui-fulldeps/rustc_public/crate-info.rs

@@ -189,7 +189,7 @@ fn get_item<'a>(
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "input.rs";

tests/ui-fulldeps/rustc_public/projections.rs

@@ -141,7 +141,7 @@ fn get_item<'a>(
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "input.rs";

tests/ui-fulldeps/rustc_public/smir_internal.rs

@@ -34,7 +34,7 @@ fn test_translation(tcx: TyCtxt<'_>) -> 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "internal_input.rs";

tests/ui-fulldeps/rustc_public/smir_serde.rs

@@ -41,7 +41,7 @@ fn serialize_to_json(_tcx: TyCtxt<'_>) -> 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "internal_input.rs";

tests/ui-fulldeps/rustc_public/smir_visitor.rs

@@ -177,7 +177,7 @@ fn visit_terminator(&mut self, term: &mut mir::Terminator, location: mir::visit:
 
 /// 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.
-/// Then it will create a `StableMir` using custom arguments and then
+/// Then it will create a `RustcPublic` using custom arguments and then
 /// it will run the compiler.
 fn main() {
     let path = "sim_visitor_input.rs";