diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs
index 0f7725664ea93..8467eaba44de6 100644
--- a/compiler/rustc_smir/src/rustc_smir/mod.rs
+++ b/compiler/rustc_smir/src/rustc_smir/mod.rs
@@ -231,50 +231,51 @@ impl<'tcx> Stable<'tcx> for mir::Statement<'tcx> {
     type T = stable_mir::mir::Statement;
     fn stable(&self, tables: &mut Tables<'tcx>) -> Self::T {
         use rustc_middle::mir::StatementKind::*;
+        let span = self.source_info.span.stable(tables);
         match &self.kind {
             Assign(assign) => Statement {
                 kind: stable_mir::mir::StatementKind::Assign(
                     assign.0.stable(tables),
                     assign.1.stable(tables),
                 ),
-                span: self.source_info.span.stable(tables),
+                span,
             },
             FakeRead(fake_read_place) => Statement {
                 kind: stable_mir::mir::StatementKind::FakeRead(
                     fake_read_place.0.stable(tables),
                     fake_read_place.1.stable(tables),
                 ),
-                span: self.source_info.span.stable(tables),
+                span,
             },
             SetDiscriminant { place: plc, variant_index: idx } => Statement {
                 kind: stable_mir::mir::StatementKind::SetDiscriminant {
                     place: plc.as_ref().stable(tables),
                     variant_index: idx.stable(tables),
                 },
-                span: self.source_info.span.stable(tables),
+                span,
             },
             Deinit(place) => Statement {
                 kind: stable_mir::mir::StatementKind::Deinit(place.stable(tables)),
-                span: self.source_info.span.stable(tables),
+                span,
             },
             StorageLive(place) => Statement {
                 kind: stable_mir::mir::StatementKind::StorageLive(place.stable(tables)),
-                span: self.source_info.span.stable(tables),
+                span,
             },
             StorageDead(place) => Statement {
                 kind: stable_mir::mir::StatementKind::StorageDead(place.stable(tables)),
-                span: self.source_info.span.stable(tables),
+                span,
             },
             Retag(retag, place) => Statement {
                 kind: stable_mir::mir::StatementKind::Retag(
                     retag.stable(tables),
                     place.stable(tables),
                 ),
-                span: self.source_info.span.stable(tables),
+                span,
             },
             PlaceMention(place) => Statement {
                 kind: stable_mir::mir::StatementKind::PlaceMention(place.stable(tables)),
-                span: self.source_info.span.stable(tables),
+                span,
             },
             AscribeUserType(place_projection, variance) => Statement {
                 kind: stable_mir::mir::StatementKind::AscribeUserType {
@@ -282,24 +283,19 @@ impl<'tcx> Stable<'tcx> for mir::Statement<'tcx> {
                     projections: place_projection.as_ref().1.stable(tables),
                     variance: variance.stable(tables),
                 },
-                span: self.source_info.span.stable(tables),
-            },
-            Coverage(coverage) => Statement {
-                kind: stable_mir::mir::StatementKind::Coverage(opaque(coverage)),
-                span: self.source_info.span.stable(tables),
+                span,
             },
+            Coverage(coverage) => {
+                Statement { kind: stable_mir::mir::StatementKind::Coverage(opaque(coverage)), span }
+            }
             Intrinsic(intrinstic) => Statement {
                 kind: stable_mir::mir::StatementKind::Intrinsic(intrinstic.stable(tables)),
-                span: self.source_info.span.stable(tables),
-            },
-            ConstEvalCounter => Statement {
-                kind: stable_mir::mir::StatementKind::ConstEvalCounter,
-                span: self.source_info.span.stable(tables),
-            },
-            Nop => Statement {
-                kind: stable_mir::mir::StatementKind::Nop,
-                span: self.source_info.span.stable(tables),
+                span,
             },
+            ConstEvalCounter => {
+                Statement { kind: stable_mir::mir::StatementKind::ConstEvalCounter, span }
+            }
+            Nop => Statement { kind: stable_mir::mir::StatementKind::Nop, span },
         }
     }
 }
@@ -851,11 +847,11 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
         use rustc_middle::mir::TerminatorKind::*;
         use stable_mir::mir::Terminator;
         use stable_mir::mir::TerminatorKind;
+        let span = self.source_info.span.stable(tables);
         match &self.kind {
-            Goto { target } => Terminator {
-                kind: TerminatorKind::Goto { target: target.as_usize() },
-                span: self.source_info.span.stable(tables),
-            },
+            Goto { target } => {
+                Terminator { kind: TerminatorKind::Goto { target: target.as_usize() }, span }
+            }
             SwitchInt { discr, targets } => Terminator {
                 kind: TerminatorKind::SwitchInt {
                     discr: discr.stable(tables),
@@ -868,31 +864,19 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
                         .collect(),
                     otherwise: targets.otherwise().as_usize(),
                 },
-                span: self.source_info.span.stable(tables),
-            },
-            UnwindResume => Terminator {
-                kind: TerminatorKind::Resume,
-                span: self.source_info.span.stable(tables),
-            },
-            UnwindTerminate(_) => Terminator {
-                kind: TerminatorKind::Abort,
-                span: self.source_info.span.stable(tables),
-            },
-            Return => Terminator {
-                kind: TerminatorKind::Return,
-                span: self.source_info.span.stable(tables),
-            },
-            Unreachable => Terminator {
-                kind: TerminatorKind::Unreachable,
-                span: self.source_info.span.stable(tables),
+                span,
             },
+            UnwindResume => Terminator { kind: TerminatorKind::Resume, span },
+            UnwindTerminate(_) => Terminator { kind: TerminatorKind::Abort, span },
+            Return => Terminator { kind: TerminatorKind::Return, span },
+            Unreachable => Terminator { kind: TerminatorKind::Unreachable, span },
             Drop { place, target, unwind, replace: _ } => Terminator {
                 kind: TerminatorKind::Drop {
                     place: place.stable(tables),
                     target: target.as_usize(),
                     unwind: unwind.stable(tables),
                 },
-                span: self.source_info.span.stable(tables),
+                span,
             },
             Call { func, args, destination, target, unwind, call_source: _, fn_span: _ } => {
                 Terminator {
@@ -903,7 +887,7 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
                         target: target.map(|t| t.as_usize()),
                         unwind: unwind.stable(tables),
                     },
-                    span: self.source_info.span.stable(tables),
+                    span,
                 }
             }
             Assert { cond, expected, msg, target, unwind } => Terminator {
@@ -914,7 +898,7 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
                     target: target.as_usize(),
                     unwind: unwind.stable(tables),
                 },
-                span: self.source_info.span.stable(tables),
+                span,
             },
             InlineAsm { template, operands, options, line_spans, destination, unwind } => {
                 Terminator {
@@ -926,7 +910,7 @@ impl<'tcx> Stable<'tcx> for mir::Terminator<'tcx> {
                         destination: destination.map(|d| d.as_usize()),
                         unwind: unwind.stable(tables),
                     },
-                    span: self.source_info.span.stable(tables),
+                    span,
                 }
             }
             Yield { .. } | GeneratorDrop | FalseEdge { .. } | FalseUnwind { .. } => unreachable!(),
diff --git a/tests/ui-fulldeps/stable-mir/crate-info.rs b/tests/ui-fulldeps/stable-mir/crate-info.rs
index ce4ee3c2463eb..d482f62ff0643 100644
--- a/tests/ui-fulldeps/stable-mir/crate-info.rs
+++ b/tests/ui-fulldeps/stable-mir/crate-info.rs
@@ -47,12 +47,12 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
     assert_eq!(body.blocks.len(), 1);
     let block = &body.blocks[0];
     assert_eq!(block.statements.len(), 1);
-    match &block.statements[0] {
-        stable_mir::mir::Statement::Assign(..) => {}
+    match &block.statements[0].kind {
+        stable_mir::mir::StatementKind::Assign(..) => {}
         other => panic!("{other:?}"),
     }
-    match &block.terminator {
-        stable_mir::mir::Terminator::Return => {}
+    match &block.terminator.kind {
+        stable_mir::mir::TerminatorKind::Return => {}
         other => panic!("{other:?}"),
     }
 
@@ -61,8 +61,8 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
     assert_eq!(body.locals.len(), 7);
     assert_eq!(body.blocks.len(), 4);
     let block = &body.blocks[0];
-    match &block.terminator {
-        stable_mir::mir::Terminator::Call { .. } => {}
+    match &block.terminator.kind {
+        stable_mir::mir::TerminatorKind::Call { .. } => {}
         other => panic!("{other:?}"),
     }
 
@@ -70,27 +70,27 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
     let body = types.body();
     assert_eq!(body.locals.len(), 6);
     assert_matches!(
-        body.locals[0].kind(),
+        body.locals[0].ty.kind(),
         stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Bool)
     );
     assert_matches!(
-        body.locals[1].kind(),
+        body.locals[1].ty.kind(),
         stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Bool)
     );
     assert_matches!(
-        body.locals[2].kind(),
+        body.locals[2].ty.kind(),
         stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Char)
     );
     assert_matches!(
-        body.locals[3].kind(),
+        body.locals[3].ty.kind(),
         stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Int(stable_mir::ty::IntTy::I32))
     );
     assert_matches!(
-        body.locals[4].kind(),
+        body.locals[4].ty.kind(),
         stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Uint(stable_mir::ty::UintTy::U64))
     );
     assert_matches!(
-        body.locals[5].kind(),
+        body.locals[5].ty.kind(),
         stable_mir::ty::TyKind::RigidTy(stable_mir::ty::RigidTy::Float(
             stable_mir::ty::FloatTy::F64
         ))
@@ -100,8 +100,8 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
     let body = drop.body();
     assert_eq!(body.blocks.len(), 2);
     let block = &body.blocks[0];
-    match &block.terminator {
-        stable_mir::mir::Terminator::Drop { .. } => {}
+    match &block.terminator.kind {
+        stable_mir::mir::TerminatorKind::Drop { .. } => {}
         other => panic!("{other:?}"),
     }
 
@@ -109,15 +109,15 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
     let body = assert.body();
     assert_eq!(body.blocks.len(), 2);
     let block = &body.blocks[0];
-    match &block.terminator {
-        stable_mir::mir::Terminator::Assert { .. } => {}
+    match &block.terminator.kind {
+        stable_mir::mir::TerminatorKind::Assert { .. } => {}
         other => panic!("{other:?}"),
     }
 
     let monomorphic = get_item(&items, (DefKind::Fn, "monomorphic")).unwrap();
     for block in monomorphic.body().blocks {
-        match &block.terminator {
-            stable_mir::mir::Terminator::Call { func, .. } => match func {
+        match &block.terminator.kind {
+            stable_mir::mir::TerminatorKind::Call { func, .. } => match func {
                 stable_mir::mir::Operand::Constant(c) => match &c.literal.literal {
                     stable_mir::ty::ConstantKind::Allocated(alloc) => {
                         assert!(alloc.bytes.is_empty());
@@ -127,7 +127,7 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
                                 mut args,
                             )) => {
                                 let func = def.body();
-                                match func.locals[1]
+                                match func.locals[1].ty
                                     .fold(&mut args)
                                     .continue_value()
                                     .unwrap()
@@ -149,7 +149,7 @@ fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
                 },
                 other => panic!("{other:?}"),
             },
-            stable_mir::mir::Terminator::Return => {}
+            stable_mir::mir::TerminatorKind::Return => {}
             other => panic!("{other:?}"),
         }
     }