Add SingleUseConsts mir-opt pass

Author: scottmcm

compiler/rustc_mir_transform/src/const_debuginfo.rs

@@ -16,7 +16,8 @@ pub struct ConstDebugInfo;
 
 impl<'tcx> MirPass<'tcx> for ConstDebugInfo {
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
-        sess.mir_opt_level() > 0
+        // Disabled in favour of `SingleUseConsts`
+        sess.mir_opt_level() > 2
     }
 
     fn run_pass(&self, _tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {

compiler/rustc_mir_transform/src/lib.rs

@@ -106,6 +106,7 @@ mod check_alignment;
 pub mod simplify;
 mod simplify_branches;
 mod simplify_comparison_integral;
+mod single_use_consts;
 mod sroa;
 mod unreachable_enum_branching;
 mod unreachable_prop;
@@ -593,6 +594,7 @@ fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
             &gvn::GVN,
             &simplify::SimplifyLocals::AfterGVN,
             &dataflow_const_prop::DataflowConstProp,
+            &single_use_consts::SingleUseConsts,
             &const_debuginfo::ConstDebugInfo,
             &o1(simplify_branches::SimplifyConstCondition::AfterConstProp),
             &jump_threading::JumpThreading,

compiler/rustc_mir_transform/src/single_use_consts.rs

@@ -0,0 +1,195 @@
+use rustc_index::{bit_set::BitSet, IndexVec};
+use rustc_middle::bug;
+use rustc_middle::mir::visit::{MutVisitor, PlaceContext, Visitor};
+use rustc_middle::mir::*;
+use rustc_middle::ty::TyCtxt;
+
+/// Various parts of MIR building introduce temporaries that are commonly not needed.
+///
+/// Notably, `if CONST` and `match CONST` end up being used-once temporaries, which
+/// obfuscates the structure for other passes and codegen, which would like to always
+/// be able to just see the constant directly.
+///
+/// At higher optimization levels fancier passes like GVN will take care of this
+/// in a more general fashion, but this handles the easy cases so can run in debug.
+///
+/// This only removes constants with a single-use because re-evaluating constants
+/// isn't always an improvement, especially for large ones.
+///
+/// It also removes *never*-used constants, since it had all the information
+/// needed to do that too, including updating the debug info.
+pub struct SingleUseConsts;
+
+impl<'tcx> MirPass<'tcx> for SingleUseConsts {
+    fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
+        sess.mir_opt_level() > 0
+    }
+
+    fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        let mut finder = SingleUseConstsFinder {
+            ineligible_locals: BitSet::new_empty(body.local_decls.len()),
+            locations: IndexVec::new(),
+        };
+
+        finder.ineligible_locals.insert_range(..=Local::from_usize(body.arg_count));
+
+        finder.visit_body(body);
+
+        for (local, locations) in finder.locations.iter_enumerated() {
+            if finder.ineligible_locals.contains(local) {
+                continue;
+            }
+
+            let Some(init_loc) = locations.init_loc else {
+                continue;
+            };
+
+            // We're only changing an operand, not the terminator kinds or successors
+            let basic_blocks = body.basic_blocks.as_mut_preserves_cfg();
+            let init_statement =
+                basic_blocks[init_loc.block].statements[init_loc.statement_index].replace_nop();
+            let StatementKind::Assign(place_and_rvalue) = init_statement.kind else {
+                bug!("No longer an assign?");
+            };
+            let (place, rvalue) = *place_and_rvalue;
+            assert_eq!(place.as_local(), Some(local));
+            let Rvalue::Use(operand) = rvalue else { bug!("No longer a use?") };
+
+            let mut replacer = LocalReplacer { tcx, local, operand: Some(operand) };
+
+            for var_debug_info in &mut body.var_debug_info {
+                replacer.visit_var_debug_info(var_debug_info);
+            }
+
+            let Some(use_loc) = locations.use_loc else { continue };
+
+            let use_block = &mut basic_blocks[use_loc.block];
+            if let Some(use_statement) = use_block.statements.get_mut(use_loc.statement_index) {
+                replacer.visit_statement(use_statement, use_loc);
+            } else {
+                replacer.visit_terminator(use_block.terminator_mut(), use_loc);
+            }
+
+            if replacer.operand.is_some() {
+                bug!(
+                    "operand wasn't used replacing local {local:?} with locations {locations:?} in body {body:#?}"
+                );
+            }
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+struct LocationPair {
+    init_loc: Option<Location>,
+    use_loc: Option<Location>,
+}
+
+impl LocationPair {
+    fn new() -> Self {
+        Self { init_loc: None, use_loc: None }
+    }
+}
+
+struct SingleUseConstsFinder {
+    ineligible_locals: BitSet<Local>,
+    locations: IndexVec<Local, LocationPair>,
+}
+
+impl<'tcx> Visitor<'tcx> for SingleUseConstsFinder {
+    fn visit_assign(&mut self, place: &Place<'tcx>, rvalue: &Rvalue<'tcx>, location: Location) {
+        if let Some(local) = place.as_local()
+            && let Rvalue::Use(operand) = rvalue
+            && let Operand::Constant(_) = operand
+        {
+            let locations = self.locations.ensure_contains_elem(local, LocationPair::new);
+            if locations.init_loc.is_some() {
+                self.ineligible_locals.insert(local);
+            } else {
+                locations.init_loc = Some(location);
+            }
+        } else {
+            self.super_assign(place, rvalue, location);
+        }
+    }
+
+    fn visit_operand(&mut self, operand: &Operand<'tcx>, location: Location) {
+        if let Some(place) = operand.place()
+            && let Some(local) = place.as_local()
+        {
+            let locations = self.locations.ensure_contains_elem(local, LocationPair::new);
+            if locations.use_loc.is_some() {
+                self.ineligible_locals.insert(local);
+            } else {
+                locations.use_loc = Some(location);
+            }
+        } else {
+            self.super_operand(operand, location);
+        }
+    }
+
+    fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) {
+        match &statement.kind {
+            // Storage markers are irrelevant to this.
+            StatementKind::StorageLive(_) | StatementKind::StorageDead(_) => {}
+            _ => self.super_statement(statement, location),
+        }
+    }
+
+    fn visit_var_debug_info(&mut self, var_debug_info: &VarDebugInfo<'tcx>) {
+        if let VarDebugInfoContents::Place(place) = &var_debug_info.value
+            && let Some(_local) = place.as_local()
+        {
+            // It's a simple one that we can easily update
+        } else {
+            self.super_var_debug_info(var_debug_info);
+        }
+    }
+
+    fn visit_local(&mut self, local: Local, _context: PlaceContext, _location: Location) {
+        // If there's any path that gets here, rather than being understood elsewhere,
+        // then we'd better not do anything with this local.
+        self.ineligible_locals.insert(local);
+    }
+}
+
+struct LocalReplacer<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    local: Local,
+    operand: Option<Operand<'tcx>>,
+}
+
+impl<'tcx> MutVisitor<'tcx> for LocalReplacer<'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn visit_operand(&mut self, operand: &mut Operand<'tcx>, _location: Location) {
+        if let Operand::Copy(place) | Operand::Move(place) = operand
+            && let Some(local) = place.as_local()
+            && local == self.local
+        {
+            *operand = self.operand.take().unwrap_or_else(|| {
+                bug!("there was a second use of the operand");
+            });
+        }
+    }
+
+    fn visit_var_debug_info(&mut self, var_debug_info: &mut VarDebugInfo<'tcx>) {
+        if let VarDebugInfoContents::Place(place) = &var_debug_info.value
+            && let Some(local) = place.as_local()
+            && local == self.local
+        {
+            let const_op = self
+                .operand
+                .as_ref()
+                .unwrap_or_else(|| {
+                    bug!("the operand was already stolen");
+                })
+                .constant()
+                .unwrap()
+                .clone();
+            var_debug_info.value = VarDebugInfoContents::Const(const_op);
+        }
+    }
+}

tests/mir-opt/building/match/sort_candidates.rs

@@ -5,9 +5,9 @@ fn constant_eq(s: &str, b: bool) -> u32 {
     // Check that we only test "a" once
 
     // CHECK-LABEL: fn constant_eq(
-    // CHECK: bb0: {
-    // CHECK: [[a:_.*]] = const "a";
-    // CHECK-NOT: {{_.*}} = const "a";
+    // CHECK-NOT: const "a"
+    // CHECK: {{_[0-9]+}} = const "a" as &[u8] (Transmute);
+    // CHECK-NOT: const "a"
     match (s, b) {
         ("a", _) if true => 1,
         ("b", true) => 2,

tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff

@@ -18,7 +18,7 @@
       bb0: {
           StorageLive(_1);
           StorageLive(_2);
-          _2 = const 1_u32;
+          nop;
           _1 = Un { us: const 1_u32 };
           StorageDead(_2);
           StorageLive(_3);

tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff

@@ -18,7 +18,7 @@
       bb0: {
           StorageLive(_1);
           StorageLive(_2);
-          _2 = const 1_u32;
+          nop;
           _1 = Un { us: const 1_u32 };
           StorageDead(_2);
           StorageLive(_3);

tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff

@@ -29,8 +29,8 @@
           _3 = &_4;
           _2 = move _3 as &[T] (PointerCoercion(Unsize));
           StorageDead(_3);
-          _5 = const 3_usize;
-          _6 = const true;
+          nop;
+          nop;
           goto -> bb2;
       }
 

tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff

@@ -29,8 +29,8 @@
           _3 = &_4;
           _2 = move _3 as &[T] (PointerCoercion(Unsize));
           StorageDead(_3);
-          _5 = const 3_usize;
-          _6 = const true;
+          nop;
+          nop;
           goto -> bb2;
       }
 

tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff

@@ -23,16 +23,15 @@
               let mut _12: isize;
               let _13: std::alloc::AllocError;
               let mut _14: !;
-              let _15: &str;
-              let mut _16: &dyn std::fmt::Debug;
-              let mut _17: &std::alloc::AllocError;
+              let mut _15: &dyn std::fmt::Debug;
+              let mut _16: &std::alloc::AllocError;
               scope 7 {
               }
               scope 8 {
               }
           }
           scope 9 (inlined NonNull::<[u8]>::as_ptr) {
-              let mut _18: *const [u8];
+              let mut _17: *const [u8];
           }
       }
       scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) {
@@ -87,36 +86,33 @@
           StorageDead(_8);
           StorageDead(_7);
           StorageLive(_12);
-          StorageLive(_15);
           _12 = discriminant(_6);
           switchInt(move _12) -> [0: bb6, 1: bb5, otherwise: bb1];
       }
 
       bb5: {
-          _15 = const "called `Result::unwrap()` on an `Err` value";
+          StorageLive(_15);
           StorageLive(_16);
-          StorageLive(_17);
-          _17 = &_13;
-          _16 = move _17 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
-          StorageDead(_17);
-          _14 = result::unwrap_failed(move _15, move _16) -> unwind unreachable;
+          _16 = &_13;
+          _15 = move _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
+          StorageDead(_16);
+          _14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable;
       }
 
       bb6: {
           _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>);
-          StorageDead(_15);
           StorageDead(_12);
           StorageDead(_6);
--         StorageLive(_18);
+-         StorageLive(_17);
 +         nop;
-          _18 = (_5.0: *const [u8]);
--         _4 = move _18 as *mut [u8] (PtrToPtr);
--         StorageDead(_18);
-+         _4 = _18 as *mut [u8] (PtrToPtr);
+          _17 = (_5.0: *const [u8]);
+-         _4 = move _17 as *mut [u8] (PtrToPtr);
+-         StorageDead(_17);
++         _4 = _17 as *mut [u8] (PtrToPtr);
 +         nop;
           StorageDead(_5);
 -         _3 = move _4 as *mut u8 (PtrToPtr);
-+         _3 = _18 as *mut u8 (PtrToPtr);
++         _3 = _17 as *mut u8 (PtrToPtr);
           StorageDead(_4);
           StorageDead(_3);
 -         StorageDead(_1);

tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff

@@ -23,16 +23,15 @@
               let mut _12: isize;
               let _13: std::alloc::AllocError;
               let mut _14: !;
-              let _15: &str;
-              let mut _16: &dyn std::fmt::Debug;
-              let mut _17: &std::alloc::AllocError;
+              let mut _15: &dyn std::fmt::Debug;
+              let mut _16: &std::alloc::AllocError;
               scope 7 {
               }
               scope 8 {
               }
           }
           scope 9 (inlined NonNull::<[u8]>::as_ptr) {
-              let mut _18: *const [u8];
+              let mut _17: *const [u8];
           }
       }
       scope 3 (inlined #[track_caller] Option::<Layout>::unwrap) {
@@ -87,36 +86,33 @@
           StorageDead(_8);
           StorageDead(_7);
           StorageLive(_12);
-          StorageLive(_15);
           _12 = discriminant(_6);
           switchInt(move _12) -> [0: bb6, 1: bb5, otherwise: bb1];
       }
 
       bb5: {
-          _15 = const "called `Result::unwrap()` on an `Err` value";
+          StorageLive(_15);
           StorageLive(_16);
-          StorageLive(_17);
-          _17 = &_13;
-          _16 = move _17 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
-          StorageDead(_17);
-          _14 = result::unwrap_failed(move _15, move _16) -> unwind unreachable;
+          _16 = &_13;
+          _15 = move _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
+          StorageDead(_16);
+          _14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable;
       }
 
       bb6: {
           _5 = move ((_6 as Ok).0: std::ptr::NonNull<[u8]>);
-          StorageDead(_15);
           StorageDead(_12);
           StorageDead(_6);
--         StorageLive(_18);
+-         StorageLive(_17);
 +         nop;
-          _18 = (_5.0: *const [u8]);
--         _4 = move _18 as *mut [u8] (PtrToPtr);
--         StorageDead(_18);
-+         _4 = _18 as *mut [u8] (PtrToPtr);
+          _17 = (_5.0: *const [u8]);
+-         _4 = move _17 as *mut [u8] (PtrToPtr);
+-         StorageDead(_17);
++         _4 = _17 as *mut [u8] (PtrToPtr);
 +         nop;
           StorageDead(_5);
 -         _3 = move _4 as *mut u8 (PtrToPtr);
-+         _3 = _18 as *mut u8 (PtrToPtr);
++         _3 = _17 as *mut u8 (PtrToPtr);
           StorageDead(_4);
           StorageDead(_3);
 -         StorageDead(_1);

tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir

@@ -4,35 +4,34 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _12: std::slice::Iter<'_, T>;
+    let mut _11: std::slice::Iter<'_, T>;
+    let mut _12: std::iter::Enumerate<std::slice::Iter<'_, T>>;
     let mut _13: std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _14: std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _15: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _16: std::option::Option<(usize, &T)>;
-    let mut _17: isize;
-    let mut _20: &impl Fn(usize, &T);
-    let mut _21: (usize, &T);
-    let _22: ();
+    let mut _14: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
+    let mut _15: std::option::Option<(usize, &T)>;
+    let mut _16: isize;
+    let mut _19: &impl Fn(usize, &T);
+    let mut _20: (usize, &T);
+    let _21: ();
     scope 1 {
-        debug iter => _14;
-        let _18: usize;
-        let _19: &T;
+        debug iter => _13;
+        let _17: usize;
+        let _18: &T;
         scope 2 {
-            debug i => _18;
-            debug x => _19;
+            debug i => _17;
+            debug x => _18;
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
         scope 4 (inlined std::slice::Iter::<'_, T>::new) {
             let _3: usize;
-            let mut _7: bool;
+            let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _9: *mut T;
-            let mut _11: *const T;
+            let mut _10: *const T;
             scope 5 {
                 let _6: std::ptr::NonNull<T>;
                 scope 6 {
-                    let _10: *const T;
+                    let _9: *const T;
                     scope 7 {
                     }
                     scope 11 (inlined without_provenance::<T>) {
@@ -61,7 +60,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb0: {
-        StorageLive(_12);
+        StorageLive(_11);
         StorageLive(_3);
         StorageLive(_6);
         StorageLive(_4);
@@ -70,62 +69,59 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
-        StorageLive(_10);
-        StorageLive(_7);
-        _7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
-        switchInt(move _7) -> [0: bb1, otherwise: bb2];
+        StorageLive(_9);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageLive(_9);
         StorageLive(_8);
-        _8 = _4 as *mut T (PtrToPtr);
-        _9 = Offset(_8, _3);
+        StorageLive(_7);
+        _7 = _4 as *mut T (PtrToPtr);
+        _8 = Offset(_7, _3);
+        StorageDead(_7);
+        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
         StorageDead(_8);
-        _10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
-        StorageDead(_9);
         goto -> bb3;
     }
 
     bb2: {
-        _10 = _3 as *const T (Transmute);
+        _9 = _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
-        StorageDead(_7);
-        StorageLive(_11);
-        _11 = _10;
-        _12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
-        StorageDead(_11);
+        StorageLive(_10);
+        _10 = _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
+        StorageDead(_9);
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
-        _13 = Enumerate::<std::slice::Iter<'_, T>> { iter: _12, count: const 0_usize };
-        StorageDead(_12);
-        StorageLive(_14);
-        _14 = _13;
+        _12 = Enumerate::<std::slice::Iter<'_, T>> { iter: _11, count: const 0_usize };
+        StorageDead(_11);
+        StorageLive(_13);
+        _13 = _12;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_16);
         StorageLive(_15);
-        _15 = &mut _14;
-        _16 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _15) -> [return: bb5, unwind unreachable];
+        StorageLive(_14);
+        _14 = &mut _13;
+        _15 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _14) -> [return: bb5, unwind unreachable];
     }
 
     bb5: {
-        StorageDead(_15);
-        _17 = discriminant(_16);
-        switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageDead(_14);
+        _16 = discriminant(_15);
+        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
     }
 
     bb6: {
-        StorageDead(_16);
-        StorageDead(_14);
+        StorageDead(_15);
+        StorageDead(_13);
         drop(_2) -> [return: bb7, unwind unreachable];
     }
 
@@ -134,19 +130,19 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb8: {
-        _18 = (((_16 as Some).0: (usize, &T)).0: usize);
-        _19 = (((_16 as Some).0: (usize, &T)).1: &T);
+        _17 = (((_15 as Some).0: (usize, &T)).0: usize);
+        _18 = (((_15 as Some).0: (usize, &T)).1: &T);
+        StorageLive(_19);
+        _19 = &_2;
         StorageLive(_20);
-        _20 = &_2;
-        StorageLive(_21);
-        _21 = (_18, _19);
-        _22 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _20, move _21) -> [return: bb9, unwind unreachable];
+        _20 = (_17, _18);
+        _21 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _19, move _20) -> [return: bb9, unwind unreachable];
     }
 
     bb9: {
-        StorageDead(_21);
         StorageDead(_20);
-        StorageDead(_16);
+        StorageDead(_19);
+        StorageDead(_15);
         goto -> bb4;
     }
 

tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir

@@ -4,35 +4,34 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _12: std::slice::Iter<'_, T>;
+    let mut _11: std::slice::Iter<'_, T>;
+    let mut _12: std::iter::Enumerate<std::slice::Iter<'_, T>>;
     let mut _13: std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _14: std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _15: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _16: std::option::Option<(usize, &T)>;
-    let mut _17: isize;
-    let mut _20: &impl Fn(usize, &T);
-    let mut _21: (usize, &T);
-    let _22: ();
+    let mut _14: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
+    let mut _15: std::option::Option<(usize, &T)>;
+    let mut _16: isize;
+    let mut _19: &impl Fn(usize, &T);
+    let mut _20: (usize, &T);
+    let _21: ();
     scope 1 {
-        debug iter => _14;
-        let _18: usize;
-        let _19: &T;
+        debug iter => _13;
+        let _17: usize;
+        let _18: &T;
         scope 2 {
-            debug i => _18;
-            debug x => _19;
+            debug i => _17;
+            debug x => _18;
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
         scope 4 (inlined std::slice::Iter::<'_, T>::new) {
             let _3: usize;
-            let mut _7: bool;
+            let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _9: *mut T;
-            let mut _11: *const T;
+            let mut _10: *const T;
             scope 5 {
                 let _6: std::ptr::NonNull<T>;
                 scope 6 {
-                    let _10: *const T;
+                    let _9: *const T;
                     scope 7 {
                     }
                     scope 11 (inlined without_provenance::<T>) {
@@ -61,7 +60,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb0: {
-        StorageLive(_12);
+        StorageLive(_11);
         StorageLive(_3);
         StorageLive(_6);
         StorageLive(_4);
@@ -70,62 +69,59 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
-        StorageLive(_10);
-        StorageLive(_7);
-        _7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
-        switchInt(move _7) -> [0: bb1, otherwise: bb2];
+        StorageLive(_9);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageLive(_9);
         StorageLive(_8);
-        _8 = _4 as *mut T (PtrToPtr);
-        _9 = Offset(_8, _3);
+        StorageLive(_7);
+        _7 = _4 as *mut T (PtrToPtr);
+        _8 = Offset(_7, _3);
+        StorageDead(_7);
+        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
         StorageDead(_8);
-        _10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
-        StorageDead(_9);
         goto -> bb3;
     }
 
     bb2: {
-        _10 = _3 as *const T (Transmute);
+        _9 = _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
-        StorageDead(_7);
-        StorageLive(_11);
-        _11 = _10;
-        _12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
-        StorageDead(_11);
+        StorageLive(_10);
+        _10 = _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
+        StorageDead(_9);
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
-        _13 = Enumerate::<std::slice::Iter<'_, T>> { iter: _12, count: const 0_usize };
-        StorageDead(_12);
-        StorageLive(_14);
-        _14 = _13;
+        _12 = Enumerate::<std::slice::Iter<'_, T>> { iter: _11, count: const 0_usize };
+        StorageDead(_11);
+        StorageLive(_13);
+        _13 = _12;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_16);
         StorageLive(_15);
-        _15 = &mut _14;
-        _16 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _15) -> [return: bb5, unwind: bb11];
+        StorageLive(_14);
+        _14 = &mut _13;
+        _15 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _14) -> [return: bb5, unwind: bb11];
     }
 
     bb5: {
-        StorageDead(_15);
-        _17 = discriminant(_16);
-        switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageDead(_14);
+        _16 = discriminant(_15);
+        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
     }
 
     bb6: {
-        StorageDead(_16);
-        StorageDead(_14);
+        StorageDead(_15);
+        StorageDead(_13);
         drop(_2) -> [return: bb7, unwind continue];
     }
 
@@ -134,19 +130,19 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb8: {
-        _18 = (((_16 as Some).0: (usize, &T)).0: usize);
-        _19 = (((_16 as Some).0: (usize, &T)).1: &T);
+        _17 = (((_15 as Some).0: (usize, &T)).0: usize);
+        _18 = (((_15 as Some).0: (usize, &T)).1: &T);
+        StorageLive(_19);
+        _19 = &_2;
         StorageLive(_20);
-        _20 = &_2;
-        StorageLive(_21);
-        _21 = (_18, _19);
-        _22 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _20, move _21) -> [return: bb9, unwind: bb11];
+        _20 = (_17, _18);
+        _21 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _19, move _20) -> [return: bb9, unwind: bb11];
     }
 
     bb9: {
-        StorageDead(_21);
         StorageDead(_20);
-        StorageDead(_16);
+        StorageDead(_19);
+        StorageDead(_15);
         goto -> bb4;
     }
 

tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir

@@ -4,32 +4,31 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
+    let mut _11: std::slice::Iter<'_, T>;
     let mut _12: std::slice::Iter<'_, T>;
-    let mut _13: std::slice::Iter<'_, T>;
-    let mut _14: &mut std::slice::Iter<'_, T>;
-    let mut _15: std::option::Option<&T>;
-    let mut _16: isize;
-    let mut _18: &impl Fn(&T);
-    let mut _19: (&T,);
-    let _20: ();
+    let mut _13: &mut std::slice::Iter<'_, T>;
+    let mut _14: std::option::Option<&T>;
+    let mut _15: isize;
+    let mut _17: &impl Fn(&T);
+    let mut _18: (&T,);
+    let _19: ();
     scope 1 {
-        debug iter => _13;
-        let _17: &T;
+        debug iter => _12;
+        let _16: &T;
         scope 2 {
-            debug x => _17;
+            debug x => _16;
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
         scope 4 (inlined std::slice::Iter::<'_, T>::new) {
             let _3: usize;
-            let mut _7: bool;
+            let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _9: *mut T;
-            let mut _11: *const T;
+            let mut _10: *const T;
             scope 5 {
                 let _6: std::ptr::NonNull<T>;
                 scope 6 {
-                    let _10: *const T;
+                    let _9: *const T;
                     scope 7 {
                     }
                     scope 11 (inlined without_provenance::<T>) {
@@ -62,60 +61,57 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
-        StorageLive(_10);
-        StorageLive(_7);
-        _7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
-        switchInt(move _7) -> [0: bb1, otherwise: bb2];
+        StorageLive(_9);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageLive(_9);
         StorageLive(_8);
-        _8 = _4 as *mut T (PtrToPtr);
-        _9 = Offset(_8, _3);
+        StorageLive(_7);
+        _7 = _4 as *mut T (PtrToPtr);
+        _8 = Offset(_7, _3);
+        StorageDead(_7);
+        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
         StorageDead(_8);
-        _10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
-        StorageDead(_9);
         goto -> bb3;
     }
 
     bb2: {
-        _10 = _3 as *const T (Transmute);
+        _9 = _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
-        StorageDead(_7);
-        StorageLive(_11);
-        _11 = _10;
-        _12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
-        StorageDead(_11);
+        StorageLive(_10);
+        _10 = _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
+        StorageDead(_9);
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
-        StorageLive(_13);
-        _13 = _12;
+        StorageLive(_12);
+        _12 = _11;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_15);
         StorageLive(_14);
-        _14 = &mut _13;
-        _15 = <std::slice::Iter<'_, T> as Iterator>::next(move _14) -> [return: bb5, unwind unreachable];
+        StorageLive(_13);
+        _13 = &mut _12;
+        _14 = <std::slice::Iter<'_, T> as Iterator>::next(move _13) -> [return: bb5, unwind unreachable];
     }
 
     bb5: {
-        StorageDead(_14);
-        _16 = discriminant(_15);
-        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageDead(_13);
+        _15 = discriminant(_14);
+        switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10];
     }
 
     bb6: {
-        StorageDead(_15);
-        StorageDead(_13);
+        StorageDead(_14);
+        StorageDead(_12);
         drop(_2) -> [return: bb7, unwind unreachable];
     }
 
@@ -124,18 +120,18 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb8: {
-        _17 = ((_15 as Some).0: &T);
+        _16 = ((_14 as Some).0: &T);
+        StorageLive(_17);
+        _17 = &_2;
         StorageLive(_18);
-        _18 = &_2;
-        StorageLive(_19);
-        _19 = (_17,);
-        _20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind unreachable];
+        _18 = (_16,);
+        _19 = <impl Fn(&T) as Fn<(&T,)>>::call(move _17, move _18) -> [return: bb9, unwind unreachable];
     }
 
     bb9: {
-        StorageDead(_19);
         StorageDead(_18);
-        StorageDead(_15);
+        StorageDead(_17);
+        StorageDead(_14);
         goto -> bb4;
     }
 

tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir

@@ -4,32 +4,31 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
+    let mut _11: std::slice::Iter<'_, T>;
     let mut _12: std::slice::Iter<'_, T>;
-    let mut _13: std::slice::Iter<'_, T>;
-    let mut _14: &mut std::slice::Iter<'_, T>;
-    let mut _15: std::option::Option<&T>;
-    let mut _16: isize;
-    let mut _18: &impl Fn(&T);
-    let mut _19: (&T,);
-    let _20: ();
+    let mut _13: &mut std::slice::Iter<'_, T>;
+    let mut _14: std::option::Option<&T>;
+    let mut _15: isize;
+    let mut _17: &impl Fn(&T);
+    let mut _18: (&T,);
+    let _19: ();
     scope 1 {
-        debug iter => _13;
-        let _17: &T;
+        debug iter => _12;
+        let _16: &T;
         scope 2 {
-            debug x => _17;
+            debug x => _16;
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
         scope 4 (inlined std::slice::Iter::<'_, T>::new) {
             let _3: usize;
-            let mut _7: bool;
+            let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _9: *mut T;
-            let mut _11: *const T;
+            let mut _10: *const T;
             scope 5 {
                 let _6: std::ptr::NonNull<T>;
                 scope 6 {
-                    let _10: *const T;
+                    let _9: *const T;
                     scope 7 {
                     }
                     scope 11 (inlined without_provenance::<T>) {
@@ -62,60 +61,57 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
-        StorageLive(_10);
-        StorageLive(_7);
-        _7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
-        switchInt(move _7) -> [0: bb1, otherwise: bb2];
+        StorageLive(_9);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageLive(_9);
         StorageLive(_8);
-        _8 = _4 as *mut T (PtrToPtr);
-        _9 = Offset(_8, _3);
+        StorageLive(_7);
+        _7 = _4 as *mut T (PtrToPtr);
+        _8 = Offset(_7, _3);
+        StorageDead(_7);
+        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
         StorageDead(_8);
-        _10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
-        StorageDead(_9);
         goto -> bb3;
     }
 
     bb2: {
-        _10 = _3 as *const T (Transmute);
+        _9 = _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
-        StorageDead(_7);
-        StorageLive(_11);
-        _11 = _10;
-        _12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
-        StorageDead(_11);
+        StorageLive(_10);
+        _10 = _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
+        StorageDead(_9);
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
-        StorageLive(_13);
-        _13 = _12;
+        StorageLive(_12);
+        _12 = _11;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_15);
         StorageLive(_14);
-        _14 = &mut _13;
-        _15 = <std::slice::Iter<'_, T> as Iterator>::next(move _14) -> [return: bb5, unwind: bb11];
+        StorageLive(_13);
+        _13 = &mut _12;
+        _14 = <std::slice::Iter<'_, T> as Iterator>::next(move _13) -> [return: bb5, unwind: bb11];
     }
 
     bb5: {
-        StorageDead(_14);
-        _16 = discriminant(_15);
-        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageDead(_13);
+        _15 = discriminant(_14);
+        switchInt(move _15) -> [0: bb6, 1: bb8, otherwise: bb10];
     }
 
     bb6: {
-        StorageDead(_15);
-        StorageDead(_13);
+        StorageDead(_14);
+        StorageDead(_12);
         drop(_2) -> [return: bb7, unwind continue];
     }
 
@@ -124,18 +120,18 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb8: {
-        _17 = ((_15 as Some).0: &T);
+        _16 = ((_14 as Some).0: &T);
+        StorageLive(_17);
+        _17 = &_2;
         StorageLive(_18);
-        _18 = &_2;
-        StorageLive(_19);
-        _19 = (_17,);
-        _20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind: bb11];
+        _18 = (_16,);
+        _19 = <impl Fn(&T) as Fn<(&T,)>>::call(move _17, move _18) -> [return: bb9, unwind: bb11];
     }
 
     bb9: {
-        StorageDead(_19);
         StorageDead(_18);
-        StorageDead(_15);
+        StorageDead(_17);
+        StorageDead(_14);
         goto -> bb4;
     }
 

tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir

@@ -4,35 +4,34 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _12: std::slice::Iter<'_, T>;
+    let mut _11: std::slice::Iter<'_, T>;
+    let mut _12: std::iter::Rev<std::slice::Iter<'_, T>>;
     let mut _13: std::iter::Rev<std::slice::Iter<'_, T>>;
-    let mut _14: std::iter::Rev<std::slice::Iter<'_, T>>;
-    let mut _16: std::option::Option<&T>;
-    let mut _17: isize;
-    let mut _19: &impl Fn(&T);
-    let mut _20: (&T,);
-    let _21: ();
+    let mut _15: std::option::Option<&T>;
+    let mut _16: isize;
+    let mut _18: &impl Fn(&T);
+    let mut _19: (&T,);
+    let _20: ();
     scope 1 {
-        debug iter => _14;
-        let _18: &T;
+        debug iter => _13;
+        let _17: &T;
         scope 2 {
-            debug x => _18;
+            debug x => _17;
         }
         scope 17 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
-            let mut _15: &mut std::slice::Iter<'_, T>;
+            let mut _14: &mut std::slice::Iter<'_, T>;
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
         scope 4 (inlined std::slice::Iter::<'_, T>::new) {
             let _3: usize;
-            let mut _7: bool;
+            let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _9: *mut T;
-            let mut _11: *const T;
+            let mut _10: *const T;
             scope 5 {
                 let _6: std::ptr::NonNull<T>;
                 scope 6 {
-                    let _10: *const T;
+                    let _9: *const T;
                     scope 7 {
                     }
                     scope 11 (inlined without_provenance::<T>) {
@@ -61,7 +60,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb0: {
-        StorageLive(_12);
+        StorageLive(_11);
         StorageLive(_3);
         StorageLive(_6);
         StorageLive(_4);
@@ -70,62 +69,59 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
-        StorageLive(_10);
-        StorageLive(_7);
-        _7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
-        switchInt(move _7) -> [0: bb1, otherwise: bb2];
+        StorageLive(_9);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageLive(_9);
         StorageLive(_8);
-        _8 = _4 as *mut T (PtrToPtr);
-        _9 = Offset(_8, _3);
+        StorageLive(_7);
+        _7 = _4 as *mut T (PtrToPtr);
+        _8 = Offset(_7, _3);
+        StorageDead(_7);
+        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
         StorageDead(_8);
-        _10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
-        StorageDead(_9);
         goto -> bb3;
     }
 
     bb2: {
-        _10 = _3 as *const T (Transmute);
+        _9 = _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
-        StorageDead(_7);
-        StorageLive(_11);
-        _11 = _10;
-        _12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
-        StorageDead(_11);
+        StorageLive(_10);
+        _10 = _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
+        StorageDead(_9);
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
-        _13 = Rev::<std::slice::Iter<'_, T>> { iter: _12 };
-        StorageDead(_12);
-        StorageLive(_14);
-        _14 = _13;
+        _12 = Rev::<std::slice::Iter<'_, T>> { iter: _11 };
+        StorageDead(_11);
+        StorageLive(_13);
+        _13 = _12;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_16);
         StorageLive(_15);
-        _15 = &mut (_14.0: std::slice::Iter<'_, T>);
-        _16 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _15) -> [return: bb5, unwind unreachable];
+        StorageLive(_14);
+        _14 = &mut (_13.0: std::slice::Iter<'_, T>);
+        _15 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _14) -> [return: bb5, unwind unreachable];
     }
 
     bb5: {
-        StorageDead(_15);
-        _17 = discriminant(_16);
-        switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageDead(_14);
+        _16 = discriminant(_15);
+        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
     }
 
     bb6: {
-        StorageDead(_16);
-        StorageDead(_14);
+        StorageDead(_15);
+        StorageDead(_13);
         drop(_2) -> [return: bb7, unwind unreachable];
     }
 
@@ -134,18 +130,18 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb8: {
-        _18 = ((_16 as Some).0: &T);
+        _17 = ((_15 as Some).0: &T);
+        StorageLive(_18);
+        _18 = &_2;
         StorageLive(_19);
-        _19 = &_2;
-        StorageLive(_20);
-        _20 = (_18,);
-        _21 = <impl Fn(&T) as Fn<(&T,)>>::call(move _19, move _20) -> [return: bb9, unwind unreachable];
+        _19 = (_17,);
+        _20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind unreachable];
     }
 
     bb9: {
-        StorageDead(_20);
         StorageDead(_19);
-        StorageDead(_16);
+        StorageDead(_18);
+        StorageDead(_15);
         goto -> bb4;
     }
 

tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir

@@ -4,35 +4,34 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _12: std::slice::Iter<'_, T>;
+    let mut _11: std::slice::Iter<'_, T>;
+    let mut _12: std::iter::Rev<std::slice::Iter<'_, T>>;
     let mut _13: std::iter::Rev<std::slice::Iter<'_, T>>;
-    let mut _14: std::iter::Rev<std::slice::Iter<'_, T>>;
-    let mut _16: std::option::Option<&T>;
-    let mut _17: isize;
-    let mut _19: &impl Fn(&T);
-    let mut _20: (&T,);
-    let _21: ();
+    let mut _15: std::option::Option<&T>;
+    let mut _16: isize;
+    let mut _18: &impl Fn(&T);
+    let mut _19: (&T,);
+    let _20: ();
     scope 1 {
-        debug iter => _14;
-        let _18: &T;
+        debug iter => _13;
+        let _17: &T;
         scope 2 {
-            debug x => _18;
+            debug x => _17;
         }
         scope 17 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
-            let mut _15: &mut std::slice::Iter<'_, T>;
+            let mut _14: &mut std::slice::Iter<'_, T>;
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
         scope 4 (inlined std::slice::Iter::<'_, T>::new) {
             let _3: usize;
-            let mut _7: bool;
+            let mut _7: *mut T;
             let mut _8: *mut T;
-            let mut _9: *mut T;
-            let mut _11: *const T;
+            let mut _10: *const T;
             scope 5 {
                 let _6: std::ptr::NonNull<T>;
                 scope 6 {
-                    let _10: *const T;
+                    let _9: *const T;
                     scope 7 {
                     }
                     scope 11 (inlined without_provenance::<T>) {
@@ -61,7 +60,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb0: {
-        StorageLive(_12);
+        StorageLive(_11);
         StorageLive(_3);
         StorageLive(_6);
         StorageLive(_4);
@@ -70,62 +69,59 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
-        StorageLive(_10);
-        StorageLive(_7);
-        _7 = const <T as std::mem::SizedTypeProperties>::IS_ZST;
-        switchInt(move _7) -> [0: bb1, otherwise: bb2];
+        StorageLive(_9);
+        switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageLive(_9);
         StorageLive(_8);
-        _8 = _4 as *mut T (PtrToPtr);
-        _9 = Offset(_8, _3);
+        StorageLive(_7);
+        _7 = _4 as *mut T (PtrToPtr);
+        _8 = Offset(_7, _3);
+        StorageDead(_7);
+        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
         StorageDead(_8);
-        _10 = move _9 as *const T (PointerCoercion(MutToConstPointer));
-        StorageDead(_9);
         goto -> bb3;
     }
 
     bb2: {
-        _10 = _3 as *const T (Transmute);
+        _9 = _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
-        StorageDead(_7);
-        StorageLive(_11);
-        _11 = _10;
-        _12 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
-        StorageDead(_11);
+        StorageLive(_10);
+        _10 = _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
+        StorageDead(_9);
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
-        _13 = Rev::<std::slice::Iter<'_, T>> { iter: _12 };
-        StorageDead(_12);
-        StorageLive(_14);
-        _14 = _13;
+        _12 = Rev::<std::slice::Iter<'_, T>> { iter: _11 };
+        StorageDead(_11);
+        StorageLive(_13);
+        _13 = _12;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_16);
         StorageLive(_15);
-        _15 = &mut (_14.0: std::slice::Iter<'_, T>);
-        _16 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _15) -> [return: bb5, unwind: bb11];
+        StorageLive(_14);
+        _14 = &mut (_13.0: std::slice::Iter<'_, T>);
+        _15 = <std::slice::Iter<'_, T> as DoubleEndedIterator>::next_back(move _14) -> [return: bb5, unwind: bb11];
     }
 
     bb5: {
-        StorageDead(_15);
-        _17 = discriminant(_16);
-        switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageDead(_14);
+        _16 = discriminant(_15);
+        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
     }
 
     bb6: {
-        StorageDead(_16);
-        StorageDead(_14);
+        StorageDead(_15);
+        StorageDead(_13);
         drop(_2) -> [return: bb7, unwind continue];
     }
 
@@ -134,18 +130,18 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb8: {
-        _18 = ((_16 as Some).0: &T);
+        _17 = ((_15 as Some).0: &T);
+        StorageLive(_18);
+        _18 = &_2;
         StorageLive(_19);
-        _19 = &_2;
-        StorageLive(_20);
-        _20 = (_18,);
-        _21 = <impl Fn(&T) as Fn<(&T,)>>::call(move _19, move _20) -> [return: bb9, unwind: bb11];
+        _19 = (_17,);
+        _20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind: bb11];
     }
 
     bb9: {
-        StorageDead(_20);
         StorageDead(_19);
-        StorageDead(_16);
+        StorageDead(_18);
+        StorageDead(_15);
         goto -> bb4;
     }
 

tests/mir-opt/single_use_consts.assign_const_to_return.SingleUseConsts.panic-abort.diff

@@ -0,0 +1,12 @@
+- // MIR for `assign_const_to_return` before SingleUseConsts
++ // MIR for `assign_const_to_return` after SingleUseConsts
+  
+  fn assign_const_to_return() -> bool {
+      let mut _0: bool;
+  
+      bb0: {
+          _0 = const <T as MyTrait>::ASSOC_BOOL;
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.assign_const_to_return.SingleUseConsts.panic-unwind.diff

@@ -0,0 +1,12 @@
+- // MIR for `assign_const_to_return` before SingleUseConsts
++ // MIR for `assign_const_to_return` after SingleUseConsts
+  
+  fn assign_const_to_return() -> bool {
+      let mut _0: bool;
+  
+      bb0: {
+          _0 = const <T as MyTrait>::ASSOC_BOOL;
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.if_const.SingleUseConsts.panic-abort.diff

@@ -0,0 +1,31 @@
+- // MIR for `if_const` before SingleUseConsts
++ // MIR for `if_const` after SingleUseConsts
+  
+  fn if_const() -> i32 {
+      let mut _0: i32;
+      let mut _1: bool;
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = const <T as MyTrait>::ASSOC_BOOL;
+-         switchInt(move _1) -> [0: bb2, otherwise: bb1];
++         nop;
++         switchInt(const <T as MyTrait>::ASSOC_BOOL) -> [0: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          _0 = const 7_i32;
+          goto -> bb3;
+      }
+  
+      bb2: {
+          _0 = const 42_i32;
+          goto -> bb3;
+      }
+  
+      bb3: {
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.if_const.SingleUseConsts.panic-unwind.diff

@@ -0,0 +1,31 @@
+- // MIR for `if_const` before SingleUseConsts
++ // MIR for `if_const` after SingleUseConsts
+  
+  fn if_const() -> i32 {
+      let mut _0: i32;
+      let mut _1: bool;
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = const <T as MyTrait>::ASSOC_BOOL;
+-         switchInt(move _1) -> [0: bb2, otherwise: bb1];
++         nop;
++         switchInt(const <T as MyTrait>::ASSOC_BOOL) -> [0: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          _0 = const 7_i32;
+          goto -> bb3;
+      }
+  
+      bb2: {
+          _0 = const 42_i32;
+          goto -> bb3;
+      }
+  
+      bb3: {
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-abort.diff

@@ -0,0 +1,46 @@
+- // MIR for `if_const_debug` before SingleUseConsts
++ // MIR for `if_const_debug` after SingleUseConsts
+  
+  fn if_const_debug() -> i32 {
+      let mut _0: i32;
+      let _1: bool;
+      let _2: ();
+      let mut _3: bool;
+      scope 1 {
+-         debug my_bool => _1;
++         debug my_bool => const <T as MyTrait>::ASSOC_BOOL;
+      }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = const <T as MyTrait>::ASSOC_BOOL;
++         nop;
+          StorageLive(_2);
+          _2 = do_whatever() -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_2);
+          StorageLive(_3);
+-         _3 = _1;
++         _3 = const <T as MyTrait>::ASSOC_BOOL;
+          switchInt(move _3) -> [0: bb3, otherwise: bb2];
+      }
+  
+      bb2: {
+          _0 = const 7_i32;
+          goto -> bb4;
+      }
+  
+      bb3: {
+          _0 = const 42_i32;
+          goto -> bb4;
+      }
+  
+      bb4: {
+          StorageDead(_3);
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff

@@ -0,0 +1,46 @@
+- // MIR for `if_const_debug` before SingleUseConsts
++ // MIR for `if_const_debug` after SingleUseConsts
+  
+  fn if_const_debug() -> i32 {
+      let mut _0: i32;
+      let _1: bool;
+      let _2: ();
+      let mut _3: bool;
+      scope 1 {
+-         debug my_bool => _1;
++         debug my_bool => const <T as MyTrait>::ASSOC_BOOL;
+      }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = const <T as MyTrait>::ASSOC_BOOL;
++         nop;
+          StorageLive(_2);
+          _2 = do_whatever() -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
+          StorageDead(_2);
+          StorageLive(_3);
+-         _3 = _1;
++         _3 = const <T as MyTrait>::ASSOC_BOOL;
+          switchInt(move _3) -> [0: bb3, otherwise: bb2];
+      }
+  
+      bb2: {
+          _0 = const 7_i32;
+          goto -> bb4;
+      }
+  
+      bb3: {
+          _0 = const 42_i32;
+          goto -> bb4;
+      }
+  
+      bb4: {
+          StorageDead(_3);
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.keep_parameter.SingleUseConsts.panic-abort.diff

@@ -0,0 +1,14 @@
+- // MIR for `keep_parameter` before SingleUseConsts
++ // MIR for `keep_parameter` after SingleUseConsts
+  
+  fn keep_parameter(_1: i32) -> () {
+      debug other => _1;
+      let mut _0: ();
+  
+      bb0: {
+          _1 = const <T as MyTrait>::ASSOC_INT;
+          _0 = const ();
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.keep_parameter.SingleUseConsts.panic-unwind.diff

@@ -0,0 +1,14 @@
+- // MIR for `keep_parameter` before SingleUseConsts
++ // MIR for `keep_parameter` after SingleUseConsts
+  
+  fn keep_parameter(_1: i32) -> () {
+      debug other => _1;
+      let mut _0: ();
+  
+      bb0: {
+          _1 = const <T as MyTrait>::ASSOC_INT;
+          _0 = const ();
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff

@@ -0,0 +1,36 @@
+- // MIR for `match_const` before SingleUseConsts
++ // MIR for `match_const` after SingleUseConsts
+  
+  fn match_const() -> &str {
+      let mut _0: &str;
+      let mut _1: i32;
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = const <T as MyTrait>::ASSOC_INT;
+-         switchInt(_1) -> [7: bb2, 42: bb3, otherwise: bb1];
++         nop;
++         switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb2, 42: bb3, otherwise: bb1];
+      }
+  
+      bb1: {
+          _0 = const "world";
+          goto -> bb4;
+      }
+  
+      bb2: {
+          _0 = const "hello";
+          goto -> bb4;
+      }
+  
+      bb3: {
+          _0 = const "towel";
+          goto -> bb4;
+      }
+  
+      bb4: {
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff

@@ -0,0 +1,36 @@
+- // MIR for `match_const` before SingleUseConsts
++ // MIR for `match_const` after SingleUseConsts
+  
+  fn match_const() -> &str {
+      let mut _0: &str;
+      let mut _1: i32;
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = const <T as MyTrait>::ASSOC_INT;
+-         switchInt(_1) -> [7: bb2, 42: bb3, otherwise: bb1];
++         nop;
++         switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb2, 42: bb3, otherwise: bb1];
+      }
+  
+      bb1: {
+          _0 = const "world";
+          goto -> bb4;
+      }
+  
+      bb2: {
+          _0 = const "hello";
+          goto -> bb4;
+      }
+  
+      bb3: {
+          _0 = const "towel";
+          goto -> bb4;
+      }
+  
+      bb4: {
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff

@@ -0,0 +1,47 @@
+- // MIR for `match_const_debug` before SingleUseConsts
++ // MIR for `match_const_debug` after SingleUseConsts
+  
+  fn match_const_debug() -> &str {
+      let mut _0: &str;
+      let _1: i32;
+      let _2: ();
+      scope 1 {
+-         debug my_int => _1;
++         debug my_int => const <T as MyTrait>::ASSOC_INT;
+      }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = const <T as MyTrait>::ASSOC_INT;
++         nop;
+          StorageLive(_2);
+          _2 = do_whatever() -> [return: bb1, unwind unreachable];
+      }
+  
+      bb1: {
+          StorageDead(_2);
+-         switchInt(_1) -> [7: bb3, 42: bb4, otherwise: bb2];
++         switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb3, 42: bb4, otherwise: bb2];
+      }
+  
+      bb2: {
+          _0 = const "world";
+          goto -> bb5;
+      }
+  
+      bb3: {
+          _0 = const "hello";
+          goto -> bb5;
+      }
+  
+      bb4: {
+          _0 = const "towel";
+          goto -> bb5;
+      }
+  
+      bb5: {
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff

@@ -0,0 +1,47 @@
+- // MIR for `match_const_debug` before SingleUseConsts
++ // MIR for `match_const_debug` after SingleUseConsts
+  
+  fn match_const_debug() -> &str {
+      let mut _0: &str;
+      let _1: i32;
+      let _2: ();
+      scope 1 {
+-         debug my_int => _1;
++         debug my_int => const <T as MyTrait>::ASSOC_INT;
+      }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = const <T as MyTrait>::ASSOC_INT;
++         nop;
+          StorageLive(_2);
+          _2 = do_whatever() -> [return: bb1, unwind continue];
+      }
+  
+      bb1: {
+          StorageDead(_2);
+-         switchInt(_1) -> [7: bb3, 42: bb4, otherwise: bb2];
++         switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb3, 42: bb4, otherwise: bb2];
+      }
+  
+      bb2: {
+          _0 = const "world";
+          goto -> bb5;
+      }
+  
+      bb3: {
+          _0 = const "hello";
+          goto -> bb5;
+      }
+  
+      bb4: {
+          _0 = const "towel";
+          goto -> bb5;
+      }
+  
+      bb5: {
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.never_used_debug.SingleUseConsts.panic-abort.diff

@@ -0,0 +1,21 @@
+- // MIR for `never_used_debug` before SingleUseConsts
++ // MIR for `never_used_debug` after SingleUseConsts
+  
+  fn never_used_debug() -> () {
+      let mut _0: ();
+      let _1: i32;
+      scope 1 {
+-         debug my_int => _1;
++         debug my_int => const <T as MyTrait>::ASSOC_INT;
+      }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = const <T as MyTrait>::ASSOC_INT;
++         nop;
+          _0 = const ();
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.never_used_debug.SingleUseConsts.panic-unwind.diff

@@ -0,0 +1,21 @@
+- // MIR for `never_used_debug` before SingleUseConsts
++ // MIR for `never_used_debug` after SingleUseConsts
+  
+  fn never_used_debug() -> () {
+      let mut _0: ();
+      let _1: i32;
+      scope 1 {
+-         debug my_int => _1;
++         debug my_int => const <T as MyTrait>::ASSOC_INT;
+      }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = const <T as MyTrait>::ASSOC_INT;
++         nop;
+          _0 = const ();
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/single_use_consts.rs

@@ -0,0 +1,80 @@
+//@ test-mir-pass: SingleUseConsts
+//@ compile-flags: -C debuginfo=full
+// EMIT_MIR_FOR_EACH_PANIC_STRATEGY
+
+trait MyTrait {
+    const ASSOC_BOOL: bool;
+    const ASSOC_INT: i32;
+}
+
+// EMIT_MIR single_use_consts.if_const.SingleUseConsts.diff
+fn if_const<T: MyTrait>() -> i32 {
+    // CHECK-LABEL: fn if_const(
+    // CHECK: switchInt(const <T as MyTrait>::ASSOC_BOOL)
+    if T::ASSOC_BOOL { 7 } else { 42 }
+}
+
+// EMIT_MIR single_use_consts.match_const.SingleUseConsts.diff
+fn match_const<T: MyTrait>() -> &'static str {
+    // CHECK-LABEL: fn match_const(
+    // CHECK: switchInt(const <T as MyTrait>::ASSOC_INT)
+    match T::ASSOC_INT {
+        7 => "hello",
+        42 => "towel",
+        _ => "world",
+    }
+}
+
+// EMIT_MIR single_use_consts.if_const_debug.SingleUseConsts.diff
+fn if_const_debug<T: MyTrait>() -> i32 {
+    // CHECK-LABEL: fn if_const_debug(
+    // CHECK: my_bool => const <T as MyTrait>::ASSOC_BOOL;
+    // FIXME: `if` forces a temporary (unlike `match`), so the const isn't direct
+    // CHECK: _3 = const <T as MyTrait>::ASSOC_BOOL;
+    // CHECK: switchInt(move _3)
+    let my_bool = T::ASSOC_BOOL;
+    do_whatever();
+    if my_bool { 7 } else { 42 }
+}
+
+// EMIT_MIR single_use_consts.match_const_debug.SingleUseConsts.diff
+fn match_const_debug<T: MyTrait>() -> &'static str {
+    // CHECK-LABEL: fn match_const_debug(
+    // CHECK: my_int => const <T as MyTrait>::ASSOC_INT;
+    // CHECK: switchInt(const <T as MyTrait>::ASSOC_INT)
+    let my_int = T::ASSOC_INT;
+    do_whatever();
+    match my_int {
+        7 => "hello",
+        42 => "towel",
+        _ => "world",
+    }
+}
+
+// EMIT_MIR single_use_consts.never_used_debug.SingleUseConsts.diff
+#[allow(unused_variables)]
+fn never_used_debug<T: MyTrait>() {
+    // CHECK-LABEL: fn never_used_debug(
+    // CHECK: my_int => const <T as MyTrait>::ASSOC_INT;
+    // CHECK-NOT: ASSOC_INT
+    // CHECK: nop
+    // CHECK-NOT: ASSOC_INT
+    let my_int = T::ASSOC_INT;
+}
+
+// EMIT_MIR single_use_consts.assign_const_to_return.SingleUseConsts.diff
+fn assign_const_to_return<T: MyTrait>() -> bool {
+    // CHECK-LABEL: fn assign_const_to_return(
+    // CHECK: _0 = const <T as MyTrait>::ASSOC_BOOL;
+    T::ASSOC_BOOL
+}
+
+// EMIT_MIR single_use_consts.keep_parameter.SingleUseConsts.diff
+fn keep_parameter<T: MyTrait>(mut other: i32) {
+    // CHECK-LABEL: fn keep_parameter(
+    // CHECK: _1 = const <T as MyTrait>::ASSOC_INT;
+    // CHECK: _0 = const ();
+    other = T::ASSOC_INT;
+}
+
+fn do_whatever() {}