Isolate rustc internal API usage behind a compat module

Concentrate all rustc-internal API calls into src/compat/ so that
toolchain upgrades touch one module (plus driver.rs) instead of
the whole codebase.

New module layout:
  src/compat/mod.rs          - centralized extern crate + re-exports
  src/compat/bridge.rs       - OpaqueInstanceKind, internal conversions
  src/compat/mono_collect.rs - mono item collection and symbol naming
  src/compat/spans.rs        - span-to-source-location resolution
  src/compat/types.rs        - type queries (generics, fn sigs, attrs)
  src/compat/output.rs       - output filename resolution

Key change: replace middle::ty::InstanceKind<'tcx> with an owned
OpaqueInstanceKind { debug_repr, is_reify_shim }, eliminating the
'tcx lifetime parameter from SmirJson, LinkMapKey, FnSymInfo,
LinkMap, DerivedInfo, and SmirJsonDebugInfo.

After this, printer.rs has zero extern crate rustc_* declarations
and zero direct tcx.query() calls.

Author: cds-amal

src/compat/bridge.rs

@@ -0,0 +1,95 @@
+//! Stable<->internal conversions and OpaqueInstanceKind.
+//!
+//! This module wraps rustc-internal instance kind queries behind an owned,
+//! lifetime-free representation so that the rest of the codebase doesn't
+//! need to carry `'tcx` lifetimes for link map keys.
+
+use std::hash::{Hash, Hasher};
+
+use super::middle;
+use super::rustc_internal;
+use super::stable_mir;
+use super::TyCtxt;
+use stable_mir::mir::mono::Instance;
+
+/// Owned, lifetime-free replacement for `middle::ty::InstanceKind<'tcx>`.
+///
+/// The actual `InstanceKind` usage is narrow:
+/// 1. Serialized as `format!("{:?}", kind)` (a Debug string)
+/// 2. Checked via `is_reify_shim()` (a single pattern match)
+/// 3. Used for `Hash`/`Eq` in `LinkMapKey` (map keying)
+///
+/// This struct captures all three via owned data, eliminating the need
+/// to propagate the `'tcx` lifetime through `LinkMapKey`, `FnSymInfo`,
+/// `SmirJson`, and `SmirJsonDebugInfo`.
+#[derive(Clone, Debug)]
+pub struct OpaqueInstanceKind {
+    debug_repr: String,
+    pub is_reify_shim: bool,
+}
+
+impl PartialEq for OpaqueInstanceKind {
+    fn eq(&self, other: &Self) -> bool {
+        self.debug_repr == other.debug_repr
+    }
+}
+
+impl Eq for OpaqueInstanceKind {}
+
+impl Hash for OpaqueInstanceKind {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.debug_repr.hash(state);
+    }
+}
+
+impl std::fmt::Display for OpaqueInstanceKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.debug_repr)
+    }
+}
+
+/// Create a monomorphized Instance from a stable DefId (wraps `Instance::mono`).
+pub fn mono_instance(tcx: TyCtxt<'_>, id: stable_mir::DefId) -> Instance {
+    let internal_id = rustc_internal::internal(tcx, id);
+    let internal_inst = middle::ty::Instance::mono(tcx, internal_id);
+    rustc_internal::stable(internal_inst)
+}
+
+/// Resolve an unevaluated constant into a (MonoItem, symbol_name) pair.
+///
+/// This wraps `middle::ty::Instance::try_resolve` and the internal mono item
+/// symbol name resolution, keeping those internal APIs out of printer.rs.
+pub fn resolve_unevaluated_const(
+    tcx: TyCtxt<'_>,
+    def_id: stable_mir::DefId,
+    args: stable_mir::ty::GenericArgs,
+) -> (stable_mir::mir::mono::MonoItem, String) {
+    use super::middle::ty::TypingEnv;
+    let internal_def = rustc_internal::internal(tcx, def_id);
+    let internal_args = rustc_internal::internal(tcx, args);
+    let maybe_inst = middle::ty::Instance::try_resolve(
+        tcx,
+        TypingEnv::post_analysis(tcx, internal_def),
+        internal_def,
+        internal_args,
+    );
+    let inst = maybe_inst
+        .ok()
+        .flatten()
+        .unwrap_or_else(|| panic!("Failed to resolve mono item for def {:?}", def_id));
+    let internal_mono_item = middle::mir::mono::MonoItem::Fn(inst);
+    let item_name = crate::compat::mono_collect::mono_item_name_int(tcx, &internal_mono_item);
+    (rustc_internal::stable(internal_mono_item), item_name)
+}
+
+/// Extract an `OpaqueInstanceKind` from a stable MIR `Instance` by
+/// converting to the internal representation and capturing the debug
+/// string and reify-shim flag.
+pub fn instance_kind(tcx: TyCtxt<'_>, inst: &Instance) -> OpaqueInstanceKind {
+    let internal_inst = rustc_internal::internal(tcx, inst);
+    let kind = internal_inst.def;
+    OpaqueInstanceKind {
+        debug_repr: format!("{:?}", kind),
+        is_reify_shim: matches!(kind, middle::ty::InstanceKind::ReifyShim(..)),
+    }
+}

src/compat/mod.rs

@@ -0,0 +1,29 @@
+//! Compatibility layer for rustc internal APIs.
+//!
+//! All `extern crate rustc_*` declarations and direct `TyCtxt` queries live
+//! here so that toolchain upgrades only need to touch this module (plus
+//! `driver.rs`).
+
+pub extern crate rustc_middle;
+pub extern crate rustc_monomorphize;
+pub extern crate rustc_session;
+pub extern crate rustc_smir;
+pub extern crate rustc_span;
+pub extern crate stable_mir;
+
+// HACK: typically, we would source serde/serde_json separately from the compiler.
+//       However, due to issues matching crate versions when we have our own serde
+//       in addition to the rustc serde, we force ourselves to use rustc serde.
+pub extern crate serde;
+pub extern crate serde_json;
+
+pub use rustc_middle as middle;
+pub use rustc_middle::ty::TyCtxt;
+pub use rustc_smir::rustc_internal;
+pub use rustc_smir::rustc_internal::internal;
+
+pub mod bridge;
+pub mod mono_collect;
+pub mod output;
+pub mod spans;
+pub mod types;

src/compat/mono_collect.rs

@@ -0,0 +1,38 @@
+//! Mono item collection and symbol naming.
+//!
+//! Wraps `tcx.collect_and_partition_mono_items()`, `item.symbol_name()`,
+//! and the `rustc_internal` stable/internal conversions needed for naming.
+
+use super::middle;
+use super::rustc_internal;
+use super::stable_mir;
+use super::TyCtxt;
+use stable_mir::mir::mono::MonoItem;
+
+/// Collect all monomorphized items from the compiler.
+pub fn mono_collect(tcx: TyCtxt<'_>) -> Vec<MonoItem> {
+    let units = tcx.collect_and_partition_mono_items(()).1;
+    units
+        .iter()
+        .flat_map(|unit| {
+            unit.items_in_deterministic_order(tcx)
+                .iter()
+                .map(|(internal_item, _)| rustc_internal::stable(internal_item))
+                .collect::<Vec<_>>()
+        })
+        .collect()
+}
+
+/// Get the symbol name for a mono item (the mangled linker name).
+pub fn mono_item_name(tcx: TyCtxt<'_>, item: &MonoItem) -> String {
+    if let MonoItem::GlobalAsm(data) = item {
+        crate::printer::hash(data).to_string()
+    } else {
+        mono_item_name_int(tcx, &rustc_internal::internal(tcx, item))
+    }
+}
+
+/// Get the symbol name for an internal (non-stable) mono item.
+pub fn mono_item_name_int<'a>(tcx: TyCtxt<'a>, item: &middle::mir::mono::MonoItem<'a>) -> String {
+    item.symbol_name(tcx).name.into()
+}

src/compat/output.rs

@@ -0,0 +1,24 @@
+//! Output filename resolution.
+//!
+//! Wraps `tcx.output_filenames().path(OutputType::Mir)` so that callers
+//! don't need to import `rustc_session` directly.
+
+use std::path::PathBuf;
+
+use super::rustc_session::config::{OutFileName, OutputType};
+use super::TyCtxt;
+
+/// Resolved output destination for MIR-derived files.
+pub enum OutputDest {
+    Stdout,
+    File(PathBuf),
+}
+
+/// Resolve the MIR output path from the compiler session, replacing
+/// the extension with the given one.
+pub fn mir_output_path(tcx: TyCtxt<'_>, extension: &str) -> OutputDest {
+    match tcx.output_filenames(()).path(OutputType::Mir) {
+        OutFileName::Stdout => OutputDest::Stdout,
+        OutFileName::Real(path) => OutputDest::File(path.with_extension(extension)),
+    }
+}

src/compat/spans.rs

@@ -0,0 +1,27 @@
+//! Span-to-source-location resolution.
+//!
+//! Wraps the `source_map().span_to_location_info()` internal API
+//! so that callers don't need to touch `rustc_span` directly.
+
+use super::internal;
+use super::rustc_span;
+use super::stable_mir;
+use super::TyCtxt;
+use stable_mir::ty::Span;
+
+pub type SourceData = (String, usize, usize, usize, usize);
+
+/// Resolve a stable MIR span to a (file, lo_line, lo_col, hi_line, hi_col) tuple.
+pub fn resolve_span(tcx: TyCtxt<'_>, span: &Span) -> SourceData {
+    let span_internal = internal(tcx, span);
+    let (source_file, lo_line, lo_col, hi_line, hi_col) =
+        tcx.sess.source_map().span_to_location_info(span_internal);
+    let file_name = match source_file {
+        Some(sf) => sf
+            .name
+            .display(rustc_span::FileNameDisplayPreference::Remapped)
+            .to_string(),
+        None => "no-location".to_string(),
+    };
+    (file_name, lo_line, lo_col, hi_line, hi_col)
+}

src/compat/types.rs

@@ -0,0 +1,131 @@
+//! Type queries (generics, fn sigs, discriminants, attrs).
+//!
+//! Wraps `tcx.generics_of()`, `tcx.predicates_of()`, `tcx.fn_sig()`,
+//! `tcx.optimized_mir()`, `tcx.def_kind()`, `tcx.type_of()`,
+//! `tcx.has_attr()`, `adt.discriminants(tcx)`, and `tcx.fn_abi_of_fn_ptr()`.
+
+use super::middle;
+use super::middle::ty::{EarlyBinder, FnSig, GenericArgs, List, Ty, TypeFoldable, TypingEnv};
+use super::rustc_internal::{self, internal};
+use super::rustc_span;
+use super::stable_mir;
+use super::TyCtxt;
+use rustc_span::def_id::DefId;
+
+/// Collect generics/predicates chain for a DefId, walking parent scopes.
+pub fn generic_data(tcx: TyCtxt<'_>, id: DefId) -> Vec<(String, String)> {
+    let mut v = Vec::new();
+    let mut next_id = Some(id);
+    while let Some(curr_id) = next_id {
+        let params = tcx.generics_of(curr_id);
+        let preds = tcx.predicates_of(curr_id);
+        if params.parent != preds.parent {
+            panic!("Generics and predicates parent ids are distinct");
+        }
+        v.push((format!("{:#?}", params), format!("{:#?}", preds)));
+        next_id = params.parent;
+    }
+    v.reverse();
+    v
+}
+
+/// Unwrap an `EarlyBinder` in a default manner; panic on error.
+pub fn default_unwrap_early_binder<'tcx, T>(
+    tcx: TyCtxt<'tcx>,
+    id: DefId,
+    v: EarlyBinder<'tcx, T>,
+) -> T
+where
+    T: TypeFoldable<TyCtxt<'tcx>>,
+{
+    let v_copy = v.clone();
+    let body = tcx.optimized_mir(id);
+    match tcx.try_instantiate_and_normalize_erasing_regions(
+        GenericArgs::identity_for_item(tcx, id),
+        body.typing_env(tcx),
+        v,
+    ) {
+        Ok(res) => res,
+        Err(err) => {
+            println!("{:?}", err);
+            v_copy.skip_binder()
+        }
+    }
+}
+
+/// Pretty-print a type, resolving FnDef signatures via `tcx.fn_sig()`.
+pub fn print_type<'tcx>(tcx: TyCtxt<'tcx>, id: DefId, ty: EarlyBinder<'tcx, Ty<'tcx>>) -> String {
+    let kind: &middle::ty::TyKind = ty.skip_binder().kind();
+    if let middle::ty::TyKind::FnDef(fun_id, args) = kind {
+        let sig0 = tcx.fn_sig(fun_id);
+        let body = tcx.optimized_mir(id);
+        let sig1 = match tcx.try_instantiate_and_normalize_erasing_regions(
+            args,
+            body.typing_env(tcx),
+            sig0,
+        ) {
+            Ok(res) => res,
+            Err(err) => {
+                println!("{:?}", err);
+                sig0.skip_binder()
+            }
+        };
+        let sig2: FnSig<'_> = tcx.instantiate_bound_regions_with_erased(sig1);
+        format!("\nTyKind(FnDef): {:#?}", sig2)
+    } else {
+        let kind = default_unwrap_early_binder(tcx, id, ty);
+        format!("\nTyKind: {:#?}", kind)
+    }
+}
+
+/// Query the def_kind, def_path, and type_of for a DefId (debug info).
+pub fn get_def_info(tcx: TyCtxt<'_>, id: DefId) -> (String, String, String) {
+    (
+        format!("{:#?}", tcx.def_kind(id)),
+        tcx.def_path_str(id),
+        print_type(tcx, id, tcx.type_of(id)),
+    )
+}
+
+/// Check whether a CrateItem has a given attribute.
+pub fn has_attr(
+    tcx: TyCtxt<'_>,
+    item: &stable_mir::CrateItem,
+    attr: rustc_span::symbol::Symbol,
+) -> bool {
+    tcx.has_attr(rustc_internal::internal(tcx, item), attr)
+}
+
+/// Collect discriminant values for an ADT (enum) by going through internals.
+pub fn adt_discriminants(tcx: TyCtxt<'_>, adt_def: stable_mir::ty::AdtDef) -> Vec<u128> {
+    let adt_internal = rustc_internal::internal(tcx, adt_def);
+    adt_internal
+        .discriminants(tcx)
+        .map(|(_, discr)| discr.val)
+        .collect()
+}
+
+/// Resolve the ABI of a function pointer type (via `tcx.fn_abi_of_fn_ptr`).
+pub fn fn_ptr_abi(
+    tcx: TyCtxt<'_>,
+    binder_stable: stable_mir::ty::PolyFnSig,
+) -> stable_mir::abi::FnAbi {
+    let binder_internal = internal(tcx, binder_stable);
+    rustc_internal::stable(
+        tcx.fn_abi_of_fn_ptr(
+            TypingEnv::fully_monomorphized().as_query_input((binder_internal, List::empty())),
+        )
+        .unwrap(),
+    )
+}
+
+/// Convert a stable DefId to an internal DefId.
+pub fn internal_def_id(tcx: TyCtxt<'_>, id: stable_mir::DefId) -> DefId {
+    rustc_internal::internal(tcx, id)
+}
+
+/// Get the stable crate ID for the local crate.
+pub fn local_crate_id(tcx: TyCtxt<'_>) -> u64 {
+    tcx.stable_crate_id(rustc_span::def_id::LOCAL_CRATE)
+        .as_u64()
+}

src/lib.rs

@@ -1,4 +1,5 @@
 #![feature(rustc_private)]
+pub mod compat;
 pub mod driver;
 pub mod mk_graph;
 pub mod printer;

src/main.rs

@@ -1,10 +1,8 @@
 #![feature(rustc_private)]
-use std::env;
-pub mod driver;
-pub mod printer;
-use driver::stable_mir_driver;
-use printer::emit_smir;
+use stable_mir_json::driver::stable_mir_driver;
 use stable_mir_json::mk_graph::{emit_d2file, emit_dotfile};
+use stable_mir_json::printer::emit_smir;
+use std::env;
 
 fn main() {
     let mut args: Vec<String> = env::args().collect();