Add `SingleUseConsts` mir-opt pass

8 files changed, 302 insertions, 334 deletions

diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
index 17d83752fc1..465cb1a9b1f 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
+++ b/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);
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
index 1cf950402c3..925d8997b8a 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
+++ b/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);
diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir
index d979c5ec1d5..8f41fb70925 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir
+++ b/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;
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir
index 8491c49f767..17cf305468e 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir
+++ b/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;
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir
index 67dd0c85ea1..3c1bbdc8742 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir
+++ b/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;
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir
index 7c41e9e1f1b..b2ec1ea7b9f 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir
+++ b/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;
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir
index ffeef1e04a1..bf982f076de 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir
+++ b/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;
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir
index c7cd37afd86..532b8162521 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir
+++ b/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;
     }