feat(compat): add compat code for initial breakpoints (2025-01-24 through 2025-03-01)

Add cfg-gated compat code for the first three breakpoints in the
detection framework:
  - smir_has_run_compiler_fn: RunCompiler struct -> run_compiler() fn
  - smir_has_named_mono_item_partitions: MonoItemPartitions tuple -> named fields
  - smir_has_raw_ptr_kind: Rvalue::AddressOf Mutability -> RawPtrKind

These breakpoints cover nightlies 2025-01-24 through 2025-03-01 and
are prerequisites for the per-nightly golden file directories.

Author: cds-amal

src/compat/mono_collect.rs

@@ -11,7 +11,12 @@ use stable_mir::mir::mono::MonoItem;
 
 /// Collect all monomorphized items from the compiler.
 pub fn mono_collect(tcx: TyCtxt<'_>) -> Vec<MonoItem> {
+    // In nightlies >= 2025-01-27, MonoItemPartitions changed from a tuple
+    // to named fields. See build.rs BREAKPOINTS table.
+    #[cfg(not(smir_has_named_mono_item_partitions))]
     let units = tcx.collect_and_partition_mono_items(()).1;
+    #[cfg(smir_has_named_mono_item_partitions)]
+    let units = tcx.collect_and_partition_mono_items(()).codegen_units;
     units
         .iter()
         .flat_map(|unit| {

src/driver.rs

@@ -44,5 +44,10 @@ pub fn stable_mir_driver(args_outer: &[String], callback_fn: fn(TyCtxt) -> ()) {
     let early_dcx =
         rustc_session::EarlyDiagCtxt::new(rustc_session::config::ErrorOutputType::default());
     rustc_driver::init_rustc_env_logger(&early_dcx);
+    // In nightlies >= 2025-01-24, RunCompiler was replaced with a free
+    // function run_compiler(). See build.rs BREAKPOINTS table.
+    #[cfg(not(smir_has_run_compiler_fn))]
     let _ = rustc_driver::RunCompiler::new(args_outer, &mut callbacks).run();
+    #[cfg(smir_has_run_compiler_fn)]
+    rustc_driver::run_compiler(args_outer, &mut callbacks);
 }

src/mk_graph/context.rs

@@ -3,9 +3,11 @@
 use std::collections::HashMap;
 
 use crate::compat::stable_mir;
+#[cfg(not(smir_has_raw_ptr_kind))]
+use stable_mir::mir::Mutability;
 use stable_mir::mir::{
-    BorrowKind, ConstOperand, Mutability, NonDivergingIntrinsic, Operand, Rvalue, Statement,
-    StatementKind, Terminator, TerminatorKind,
+    BorrowKind, ConstOperand, NonDivergingIntrinsic, Operand, Rvalue, Statement, StatementKind,
+    Terminator, TerminatorKind,
 };
 use stable_mir::ty::{ConstantKind, IndexedVal, MirConst, Ty};
 
@@ -153,19 +155,25 @@ impl GraphContext {
             } => format!("Ascribe {}.{}", place.label(), projections.base),
             Coverage(_) => "Coverage".to_string(),
             Intrinsic(intr) => format!("Intr: {}", self.render_intrinsic(intr)),
-            ConstEvalCounter {} => "ConstEvalCounter".to_string(),
-            Nop {} => "Nop".to_string(),
+            ConstEvalCounter => "ConstEvalCounter".to_string(),
+            Nop => "Nop".to_string(),
         }
     }
 
     /// Render rvalue with context
     pub fn render_rvalue(&self, v: &Rvalue) -> String {
         use Rvalue::*;
         match v {
+            // In nightlies >= 2025-01-28, AddressOf's first field changed from
+            // Mutability (Mut/Not) to RawPtrKind (Mut/Const/FakeForPtrMetadata).
+            // See build.rs BREAKPOINTS table.
+            #[cfg(not(smir_has_raw_ptr_kind))]
             AddressOf(mutability, p) => match mutability {
                 Mutability::Not => format!("&raw {}", p.label()),
                 Mutability::Mut => format!("&raw mut {}", p.label()),
             },
+            #[cfg(smir_has_raw_ptr_kind)]
+            AddressOf(kind, p) => format!("&raw {:?} {}", kind, p.label()),
             Aggregate(kind, operands) => {
                 let os: Vec<String> = operands.iter().map(|op| self.render_operand(op)).collect();
                 format!("{} ({})", kind.label(), os.join(", "))
@@ -227,10 +235,10 @@ impl GraphContext {
         match &term.kind {
             Goto { .. } => "Goto".to_string(),
             SwitchInt { discr, .. } => format!("SwitchInt {}", self.render_operand(discr)),
-            Resume {} => "Resume".to_string(),
-            Abort {} => "Abort".to_string(),
-            Return {} => "Return".to_string(),
-            Unreachable {} => "Unreachable".to_string(),
+            Resume => "Resume".to_string(),
+            Abort => "Abort".to_string(),
+            Return => "Return".to_string(),
+            Unreachable => "Unreachable".to_string(),
             Drop { place, .. } => format!("Drop {}", place.label()),
             Call {
                 func,

src/mk_graph/output/dot.rs

@@ -125,16 +125,16 @@ impl SmirJson {
                                             .attributes()
                                             .set_label("other");
                                     }
-                                    Resume {} => {
+                                    Resume => {
                                         label_strs.push("Resume".to_string());
                                     }
-                                    Abort {} => {
+                                    Abort => {
                                         label_strs.push("Abort".to_string());
                                     }
-                                    Return {} => {
+                                    Return => {
                                         label_strs.push("Return".to_string());
                                     }
-                                    Unreachable {} => {
+                                    Unreachable => {
                                         label_strs.push("Unreachable".to_string());
                                     }
                                     TerminatorKind::Drop {

src/mk_graph/util.rs

@@ -44,16 +44,27 @@ impl GraphLabelString for Operand {
         }
     }
 }
-
+/// Some `AggregateKind` variants only exist on certain nightlies (the
+/// stable MIR API evolves across compiler versions). Arms gated with
+/// `#[cfg(smir_has_*)]` are toggled by `build.rs`, which inspects the
+/// active rustc's commit-date and emits the appropriate cfg flags.
+/// This keeps the match exhaustive on every supported nightly: without
+/// the flag the variant doesn't exist in the enum, so the arm is
+/// excluded; with the flag the arm is included to cover the new variant.
 impl GraphLabelString for AggregateKind {
     fn label(&self) -> String {
         use AggregateKind::*;
         match &self {
             Array(_ty) => "Array".to_string(),
-            Tuple {} => "Tuple".to_string(),
+            Tuple => "Tuple".to_string(),
             Adt(_, idx, _, _, _) => format!("Adt{{{}}}", idx.to_index()),
             Closure(_, _) => "Closure".to_string(),
             Coroutine(_, _, _) => "Coroutine".to_string(),
+
+            // Added in nightlies >= 2024-12-14; see build.rs BREAKPOINTS table.
+            #[cfg(smir_has_coroutine_closure)]
+            CoroutineClosure(_, _) => "CoroutineClosure".to_string(),
+
             RawPtr(ty, Mutability::Mut) => format!("*mut ({})", ty),
             RawPtr(ty, Mutability::Not) => format!("*({})", ty),
         }
@@ -64,10 +75,16 @@ impl GraphLabelString for Rvalue {
     fn label(&self) -> String {
         use Rvalue::*;
         match &self {
+            // In nightlies >= 2025-01-28, AddressOf's first field changed from
+            // Mutability (Mut/Not) to RawPtrKind (Mut/Const/FakeForPtrMetadata).
+            // See build.rs BREAKPOINTS table.
+            #[cfg(not(smir_has_raw_ptr_kind))]
             AddressOf(mutability, p) => match mutability {
                 Mutability::Not => format!("&raw {}", p.label()),
                 Mutability::Mut => format!("&raw mut {}", p.label()),
             },
+            #[cfg(smir_has_raw_ptr_kind)]
+            AddressOf(kind, p) => format!("&raw {:?} {}", kind, p.label()),
             Aggregate(kind, operands) => {
                 let os: Vec<String> = operands.iter().map(|op| op.label()).collect();
                 format!("{} ({})", kind.label(), os.join(", "))
@@ -239,7 +256,7 @@ pub fn terminator_targets(term: &Terminator) -> Vec<usize> {
             result.push(targets.otherwise());
             result
         }
-        Resume {} | Abort {} | Return {} | Unreachable {} => vec![],
+        Resume | Abort | Return | Unreachable => vec![],
         Drop { target, unwind, .. } => {
             let mut result = vec![*target];
             if let UnwindAction::Cleanup(t) = unwind {