rename CompilerInterface to SmirInterface

Author: makai410

Diff for: compiler/rustc_smir/src/rustc_internal/mod.rs

@@ -18,7 +18,7 @@ use rustc_span::def_id::{CrateNum, DefId};
 use scoped_tls::scoped_thread_local;
 use stable_mir::Error;
 use stable_mir::abi::Layout;
-use stable_mir::compiler_interface::CompilerInterface;
+use stable_mir::compiler_interface::SmirInterface;
 use stable_mir::ty::IndexedVal;
 
 use crate::rustc_smir::context::Context;
@@ -235,9 +235,9 @@ where
         layouts: IndexMap::default(),
     }));
 
-    let interface = CompilerInterface { cx: tables };
+    let interface = SmirInterface { cx: tables };
 
-    // Pass the `CompilerInterface` to compiler_interface::run
+    // Pass the `SmirInterface` to compiler_interface::run
     // and initialize the rustc-specific TLS with tables.
     stable_mir::compiler_interface::run(&interface, || init(&interface.cx, f))
 }

Diff for: compiler/rustc_smir/src/stable_mir/compiler_interface.rs

@@ -31,11 +31,11 @@ use crate::{rustc_smir, stable_mir};
 /// similar APIs but based on internal rustc constructs.
 ///
 /// Do not use this directly. This is currently used in the macro expansion.
-pub struct CompilerInterface<'tcx> {
+pub struct SmirInterface<'tcx> {
     pub(crate) cx: Context<'tcx>,
 }
 
-impl<'tcx> CompilerInterface<'tcx> {
+impl<'tcx> SmirInterface<'tcx> {
     pub fn entry_fn(&self) -> Option<CrateItem> {
         self.cx.entry_fn()
     }
@@ -461,30 +461,30 @@ impl<'tcx> CompilerInterface<'tcx> {
     }
 }
 
-// A thread local variable that stores a pointer to [`CompilerInterface`].
+// A thread local variable that stores a pointer to [`SmirInterface`].
 scoped_tls::scoped_thread_local!(static TLV: Cell<*const ()>);
 
-pub fn run<'tcx, T, F>(interface: &CompilerInterface<'tcx>, f: F) -> Result<T, Error>
+pub fn run<'tcx, T, F>(interface: &SmirInterface<'tcx>, f: F) -> Result<T, Error>
 where
     F: FnOnce() -> T,
 {
     if TLV.is_set() {
         Err(Error::from("StableMIR already running"))
     } else {
-        let ptr: *const () = (interface as *const CompilerInterface<'tcx>) as *const ();
+        let ptr: *const () = (interface as *const SmirInterface<'tcx>) as *const ();
         TLV.set(&Cell::new(ptr), || Ok(f()))
     }
 }
 
-/// Execute the given function with access the [`CompilerInterface`].
+/// Execute the given function with access the [`SmirInterface`].
 ///
 /// I.e., This function will load the current interface and calls a function with it.
 /// Do not nest these, as that will ICE.
-pub(crate) fn with<R>(f: impl FnOnce(&CompilerInterface<'_>) -> R) -> R {
+pub(crate) fn with<R>(f: impl FnOnce(&SmirInterface<'_>) -> R) -> R {
     assert!(TLV.is_set());
     TLV.with(|tlv| {
         let ptr = tlv.get();
         assert!(!ptr.is_null());
-        f(unsafe { &*(ptr as *const CompilerInterface<'_>) })
+        f(unsafe { &*(ptr as *const SmirInterface<'_>) })
     })
 }