Go back to `Some` instead of transmuting to it.

This adds a few more statements to `next`, but optimizes better in the loops (saving 2 blocks in `forward_loop`, for example)

5 files changed, 204 insertions, 163 deletions

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 80b96e01041..7ef532d222d 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
@@ -7,27 +7,27 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     let mut _11: std::ptr::NonNull<T>;
     let mut _12: *const T;
     let mut _13: usize;
-    let mut _31: std::option::Option<(usize, &T)>;
-    let mut _34: &impl Fn(usize, &T);
-    let mut _35: (usize, &T);
-    let _36: ();
+    let mut _32: std::option::Option<(usize, &T)>;
+    let mut _35: &impl Fn(usize, &T);
+    let mut _36: (usize, &T);
+    let _37: ();
     scope 1 {
         debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _11;
         debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).1: *const T) => _12;
         debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>;
         debug ((iter: Enumerate<std::slice::Iter<'_, T>>).1: usize) => _13;
-        let _32: usize;
-        let _33: &T;
+        let _33: usize;
+        let _34: &T;
         scope 2 {
-            debug i => _32;
-            debug x => _33;
+            debug i => _33;
+            debug x => _34;
         }
         scope 19 (inlined <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next) {
-            let mut _25: std::option::Option<&T>;
-            let mut _29: (usize, bool);
-            let mut _30: (usize, &T);
+            let mut _27: std::option::Option<&T>;
+            let mut _30: (usize, bool);
+            let mut _31: (usize, &T);
             scope 20 {
-                let _28: usize;
+                let _29: usize;
                 scope 25 {
                 }
             }
@@ -42,8 +42,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                 }
             }
             scope 26 (inlined <Option<&T> as Try>::branch) {
-                let mut _26: isize;
-                let _27: &T;
+                let _28: &T;
                 scope 27 {
                 }
             }
@@ -53,6 +52,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                 let mut _19: bool;
                 let mut _22: std::ptr::NonNull<T>;
                 let mut _24: usize;
+                let _26: &T;
                 scope 30 {
                     let _15: *const T;
                     scope 31 {
@@ -85,6 +85,13 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                             scope 43 (inlined NonNull::<T>::as_ptr) {
                             }
                         }
+                        scope 44 (inlined NonNull::<T>::as_ref::<'_>) {
+                            let _25: *const T;
+                            scope 45 (inlined NonNull::<T>::as_ptr) {
+                            }
+                            scope 46 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
+                            }
+                        }
                     }
                 }
             }
@@ -175,15 +182,16 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb4: {
-        StorageLive(_31);
-        StorageLive(_28);
+        StorageLive(_32);
         StorageLive(_29);
-        StorageLive(_25);
+        StorageLive(_30);
+        StorageLive(_27);
         StorageLive(_14);
         StorageLive(_15);
         StorageLive(_23);
         StorageLive(_24);
         StorageLive(_16);
+        StorageLive(_26);
         _14 = copy _11;
         _15 = copy _12;
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
@@ -214,103 +222,96 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageDead(_21);
         _11 = move _22;
         StorageDead(_22);
-        goto -> bb11;
+        goto -> bb13;
     }
 
     bb7: {
         StorageDead(_19);
+        StorageDead(_26);
         StorageDead(_16);
         StorageDead(_24);
         StorageDead(_23);
         StorageDead(_15);
         StorageDead(_14);
-        StorageLive(_26);
-        goto -> bb12;
+        goto -> bb10;
     }
 
     bb8: {
         _23 = copy _15 as usize (Transmute);
-        switchInt(copy _23) -> [0: bb9, otherwise: bb10];
+        switchInt(copy _23) -> [0: bb9, otherwise: bb12];
     }
 
     bb9: {
+        StorageDead(_26);
         StorageDead(_16);
         StorageDead(_24);
         StorageDead(_23);
         StorageDead(_15);
         StorageDead(_14);
-        StorageLive(_26);
-        goto -> bb12;
+        goto -> bb10;
     }
 
     bb10: {
-        _24 = SubUnchecked(copy _23, const 1_usize);
-        _12 = copy _24 as *const T (Transmute);
-        goto -> bb11;
-    }
-
-    bb11: {
-        _25 = copy _14 as std::option::Option<&T> (Transmute);
-        StorageDead(_16);
-        StorageDead(_24);
-        StorageDead(_23);
-        StorageDead(_15);
-        StorageDead(_14);
-        StorageLive(_26);
-        _26 = discriminant(_25);
-        switchInt(move _26) -> [0: bb12, 1: bb14, otherwise: bb17];
-    }
-
-    bb12: {
-        StorageDead(_26);
-        StorageDead(_25);
+        StorageDead(_27);
+        StorageDead(_30);
         StorageDead(_29);
-        StorageDead(_28);
-        StorageDead(_31);
+        StorageDead(_32);
         StorageDead(_11);
         StorageDead(_12);
         StorageDead(_13);
-        drop(_2) -> [return: bb13, unwind unreachable];
+        drop(_2) -> [return: bb11, unwind unreachable];
     }
 
-    bb13: {
+    bb11: {
         return;
     }
 
-    bb14: {
-        _27 = move ((_25 as Some).0: &T);
-        StorageDead(_26);
+    bb12: {
+        _24 = SubUnchecked(copy _23, const 1_usize);
+        _12 = copy _24 as *const T (Transmute);
+        goto -> bb13;
+    }
+
+    bb13: {
+        StorageLive(_25);
+        _25 = copy _14 as *const T (Transmute);
+        _26 = &(*_25);
         StorageDead(_25);
-        _28 = copy _13;
-        _29 = AddWithOverflow(copy _13, const 1_usize);
-        assert(!move (_29.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _13, const 1_usize) -> [success: bb15, unwind unreachable];
+        _27 = Option::<&T>::Some(copy _26);
+        StorageDead(_26);
+        StorageDead(_16);
+        StorageDead(_24);
+        StorageDead(_23);
+        StorageDead(_15);
+        StorageDead(_14);
+        _28 = move ((_27 as Some).0: &T);
+        StorageDead(_27);
+        _29 = copy _13;
+        _30 = AddWithOverflow(copy _13, const 1_usize);
+        assert(!move (_30.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _13, const 1_usize) -> [success: bb14, unwind unreachable];
     }
 
-    bb15: {
-        _13 = move (_29.0: usize);
-        StorageLive(_30);
-        _30 = (copy _28, copy _27);
-        _31 = Option::<(usize, &T)>::Some(move _30);
+    bb14: {
+        _13 = move (_30.0: usize);
+        StorageLive(_31);
+        _31 = (copy _29, copy _28);
+        _32 = Option::<(usize, &T)>::Some(move _31);
+        StorageDead(_31);
         StorageDead(_30);
         StorageDead(_29);
-        StorageDead(_28);
-        _32 = copy (((_31 as Some).0: (usize, &T)).0: usize);
-        _33 = copy (((_31 as Some).0: (usize, &T)).1: &T);
-        StorageLive(_34);
-        _34 = &_2;
+        _33 = copy (((_32 as Some).0: (usize, &T)).0: usize);
+        _34 = copy (((_32 as Some).0: (usize, &T)).1: &T);
         StorageLive(_35);
-        _35 = (copy _32, copy _33);
-        _36 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _34, move _35) -> [return: bb16, unwind unreachable];
+        _35 = &_2;
+        StorageLive(_36);
+        _36 = (copy _33, copy _34);
+        _37 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _35, move _36) -> [return: bb15, unwind unreachable];
     }
 
-    bb16: {
+    bb15: {
+        StorageDead(_36);
         StorageDead(_35);
-        StorageDead(_34);
-        StorageDead(_31);
+        StorageDead(_32);
         goto -> bb4;
     }
-
-    bb17: {
-        unreachable;
-    }
 }
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 c539170055d..62787f3447c 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
@@ -6,18 +6,17 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     let mut _0: ();
     let mut _11: std::ptr::NonNull<T>;
     let mut _12: *const T;
-    let mut _24: std::option::Option<&T>;
-    let mut _25: isize;
-    let mut _27: &impl Fn(&T);
-    let mut _28: (&T,);
-    let _29: ();
+    let mut _26: std::option::Option<&T>;
+    let mut _28: &impl Fn(&T);
+    let mut _29: (&T,);
+    let _30: ();
     scope 1 {
         debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _11;
         debug ((iter: std::slice::Iter<'_, T>).1: *const T) => _12;
         debug ((iter: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>;
-        let _26: &T;
+        let _27: &T;
         scope 2 {
-            debug x => _26;
+            debug x => _27;
         }
         scope 17 (inlined <std::slice::Iter<'_, T> as Iterator>::next) {
             let _13: std::ptr::NonNull<T>;
@@ -25,6 +24,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
             let mut _18: bool;
             let mut _21: std::ptr::NonNull<T>;
             let mut _23: usize;
+            let _25: &T;
             scope 18 {
                 let _14: *const T;
                 scope 19 {
@@ -57,6 +57,13 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                         scope 31 (inlined NonNull::<T>::as_ptr) {
                         }
                     }
+                    scope 32 (inlined NonNull::<T>::as_ref::<'_>) {
+                        let _24: *const T;
+                        scope 33 (inlined NonNull::<T>::as_ptr) {
+                        }
+                        scope 34 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
+                        }
+                    }
                 }
             }
         }
@@ -140,12 +147,13 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb4: {
-        StorageLive(_24);
+        StorageLive(_26);
         StorageLive(_13);
         StorageLive(_14);
         StorageLive(_22);
         StorageLive(_23);
         StorageLive(_15);
+        StorageLive(_25);
         _13 = copy _11;
         _14 = copy _12;
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
@@ -176,78 +184,76 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageDead(_20);
         _11 = move _21;
         StorageDead(_21);
-        goto -> bb11;
+        goto -> bb13;
     }
 
     bb7: {
         StorageDead(_18);
+        StorageDead(_25);
         StorageDead(_15);
         StorageDead(_23);
         StorageDead(_22);
         StorageDead(_14);
         StorageDead(_13);
-        goto -> bb12;
+        goto -> bb10;
     }
 
     bb8: {
         _22 = copy _14 as usize (Transmute);
-        switchInt(copy _22) -> [0: bb9, otherwise: bb10];
+        switchInt(copy _22) -> [0: bb9, otherwise: bb12];
     }
 
     bb9: {
+        StorageDead(_25);
         StorageDead(_15);
         StorageDead(_23);
         StorageDead(_22);
         StorageDead(_14);
         StorageDead(_13);
-        goto -> bb12;
+        goto -> bb10;
     }
 
     bb10: {
-        _23 = SubUnchecked(copy _22, const 1_usize);
-        _12 = copy _23 as *const T (Transmute);
-        goto -> bb11;
+        StorageDead(_26);
+        StorageDead(_11);
+        StorageDead(_12);
+        drop(_2) -> [return: bb11, unwind unreachable];
     }
 
     bb11: {
-        _24 = copy _13 as std::option::Option<&T> (Transmute);
-        StorageDead(_15);
-        StorageDead(_23);
-        StorageDead(_22);
-        StorageDead(_14);
-        StorageDead(_13);
-        _25 = discriminant(_24);
-        switchInt(move _25) -> [0: bb12, 1: bb14, otherwise: bb16];
+        return;
     }
 
     bb12: {
-        StorageDead(_24);
-        StorageDead(_11);
-        StorageDead(_12);
-        drop(_2) -> [return: bb13, unwind unreachable];
+        _23 = SubUnchecked(copy _22, const 1_usize);
+        _12 = copy _23 as *const T (Transmute);
+        goto -> bb13;
     }
 
     bb13: {
-        return;
-    }
-
-    bb14: {
-        _26 = copy ((_24 as Some).0: &T);
-        StorageLive(_27);
-        _27 = &_2;
+        StorageLive(_24);
+        _24 = copy _13 as *const T (Transmute);
+        _25 = &(*_24);
+        StorageDead(_24);
+        _26 = Option::<&T>::Some(copy _25);
+        StorageDead(_25);
+        StorageDead(_15);
+        StorageDead(_23);
+        StorageDead(_22);
+        StorageDead(_14);
+        StorageDead(_13);
+        _27 = copy ((_26 as Some).0: &T);
         StorageLive(_28);
-        _28 = (copy _26,);
-        _29 = <impl Fn(&T) as Fn<(&T,)>>::call(move _27, move _28) -> [return: bb15, unwind unreachable];
+        _28 = &_2;
+        StorageLive(_29);
+        _29 = (copy _27,);
+        _30 = <impl Fn(&T) as Fn<(&T,)>>::call(move _28, move _29) -> [return: bb14, unwind unreachable];
     }
 
-    bb15: {
+    bb14: {
+        StorageDead(_29);
         StorageDead(_28);
-        StorageDead(_27);
-        StorageDead(_24);
+        StorageDead(_26);
         goto -> bb4;
     }
-
-    bb16: {
-        unreachable;
-    }
 }
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 dc537ad8740..e5478e27918 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
@@ -6,18 +6,17 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     let mut _0: ();
     let mut _11: std::ptr::NonNull<T>;
     let mut _12: *const T;
-    let mut _24: std::option::Option<&T>;
-    let mut _25: isize;
-    let mut _27: &impl Fn(&T);
-    let mut _28: (&T,);
-    let _29: ();
+    let mut _26: std::option::Option<&T>;
+    let mut _28: &impl Fn(&T);
+    let mut _29: (&T,);
+    let _30: ();
     scope 1 {
         debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _11;
         debug ((iter: std::slice::Iter<'_, T>).1: *const T) => _12;
         debug ((iter: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>;
-        let _26: &T;
+        let _27: &T;
         scope 2 {
-            debug x => _26;
+            debug x => _27;
         }
         scope 17 (inlined <std::slice::Iter<'_, T> as Iterator>::next) {
             let _13: std::ptr::NonNull<T>;
@@ -25,6 +24,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
             let mut _18: bool;
             let mut _21: std::ptr::NonNull<T>;
             let mut _23: usize;
+            let _25: &T;
             scope 18 {
                 let _14: *const T;
                 scope 19 {
@@ -57,6 +57,13 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                         scope 31 (inlined NonNull::<T>::as_ptr) {
                         }
                     }
+                    scope 32 (inlined NonNull::<T>::as_ref::<'_>) {
+                        let _24: *const T;
+                        scope 33 (inlined NonNull::<T>::as_ptr) {
+                        }
+                        scope 34 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
+                        }
+                    }
                 }
             }
         }
@@ -140,12 +147,13 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb4: {
-        StorageLive(_24);
+        StorageLive(_26);
         StorageLive(_13);
         StorageLive(_14);
         StorageLive(_22);
         StorageLive(_23);
         StorageLive(_15);
+        StorageLive(_25);
         _13 = copy _11;
         _14 = copy _12;
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
@@ -176,86 +184,84 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageDead(_20);
         _11 = move _21;
         StorageDead(_21);
-        goto -> bb11;
+        goto -> bb13;
     }
 
     bb7: {
         StorageDead(_18);
+        StorageDead(_25);
         StorageDead(_15);
         StorageDead(_23);
         StorageDead(_22);
         StorageDead(_14);
         StorageDead(_13);
-        goto -> bb12;
+        goto -> bb10;
     }
 
     bb8: {
         _22 = copy _14 as usize (Transmute);
-        switchInt(copy _22) -> [0: bb9, otherwise: bb10];
+        switchInt(copy _22) -> [0: bb9, otherwise: bb12];
     }
 
     bb9: {
+        StorageDead(_25);
         StorageDead(_15);
         StorageDead(_23);
         StorageDead(_22);
         StorageDead(_14);
         StorageDead(_13);
-        goto -> bb12;
+        goto -> bb10;
     }
 
     bb10: {
-        _23 = SubUnchecked(copy _22, const 1_usize);
-        _12 = copy _23 as *const T (Transmute);
-        goto -> bb11;
+        StorageDead(_26);
+        StorageDead(_11);
+        StorageDead(_12);
+        drop(_2) -> [return: bb11, unwind continue];
     }
 
     bb11: {
-        _24 = copy _13 as std::option::Option<&T> (Transmute);
-        StorageDead(_15);
-        StorageDead(_23);
-        StorageDead(_22);
-        StorageDead(_14);
-        StorageDead(_13);
-        _25 = discriminant(_24);
-        switchInt(move _25) -> [0: bb12, 1: bb14, otherwise: bb18];
+        return;
     }
 
     bb12: {
-        StorageDead(_24);
-        StorageDead(_11);
-        StorageDead(_12);
-        drop(_2) -> [return: bb13, unwind continue];
+        _23 = SubUnchecked(copy _22, const 1_usize);
+        _12 = copy _23 as *const T (Transmute);
+        goto -> bb13;
     }
 
     bb13: {
-        return;
-    }
-
-    bb14: {
-        _26 = copy ((_24 as Some).0: &T);
-        StorageLive(_27);
-        _27 = &_2;
+        StorageLive(_24);
+        _24 = copy _13 as *const T (Transmute);
+        _25 = &(*_24);
+        StorageDead(_24);
+        _26 = Option::<&T>::Some(copy _25);
+        StorageDead(_25);
+        StorageDead(_15);
+        StorageDead(_23);
+        StorageDead(_22);
+        StorageDead(_14);
+        StorageDead(_13);
+        _27 = copy ((_26 as Some).0: &T);
         StorageLive(_28);
-        _28 = (copy _26,);
-        _29 = <impl Fn(&T) as Fn<(&T,)>>::call(move _27, move _28) -> [return: bb15, unwind: bb16];
+        _28 = &_2;
+        StorageLive(_29);
+        _29 = (copy _27,);
+        _30 = <impl Fn(&T) as Fn<(&T,)>>::call(move _28, move _29) -> [return: bb14, unwind: bb15];
     }
 
-    bb15: {
+    bb14: {
+        StorageDead(_29);
         StorageDead(_28);
-        StorageDead(_27);
-        StorageDead(_24);
+        StorageDead(_26);
         goto -> bb4;
     }
 
-    bb16 (cleanup): {
-        drop(_2) -> [return: bb17, unwind terminate(cleanup)];
+    bb15 (cleanup): {
+        drop(_2) -> [return: bb16, unwind terminate(cleanup)];
     }
 
-    bb17 (cleanup): {
+    bb16 (cleanup): {
         resume;
     }
-
-    bb18: {
-        unreachable;
-    }
 }
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir
index 0fe469c21f7..b6df2300efb 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir
@@ -9,6 +9,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         let mut _7: bool;
         let mut _10: std::ptr::NonNull<T>;
         let mut _12: usize;
+        let _14: &T;
         scope 2 {
             let _3: *const T;
             scope 3 {
@@ -41,6 +42,13 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
                     scope 15 (inlined NonNull::<T>::as_ptr) {
                     }
                 }
+                scope 16 (inlined NonNull::<T>::as_ref::<'_>) {
+                    let _13: *const T;
+                    scope 17 (inlined NonNull::<T>::as_ptr) {
+                    }
+                    scope 18 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
+                    }
+                }
             }
         }
     }
@@ -51,6 +59,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         StorageLive(_11);
         StorageLive(_12);
         StorageLive(_4);
+        StorageLive(_14);
         _2 = copy ((*_1).0: std::ptr::NonNull<T>);
         _3 = copy ((*_1).1: *const T);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb4];
@@ -107,11 +116,16 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb7: {
-        _0 = copy _2 as std::option::Option<&T> (Transmute);
+        StorageLive(_13);
+        _13 = copy _2 as *const T (Transmute);
+        _14 = &(*_13);
+        StorageDead(_13);
+        _0 = Option::<&T>::Some(copy _14);
         goto -> bb8;
     }
 
     bb8: {
+        StorageDead(_14);
         StorageDead(_4);
         StorageDead(_12);
         StorageDead(_11);
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir
index 0fe469c21f7..b6df2300efb 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir
@@ -9,6 +9,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         let mut _7: bool;
         let mut _10: std::ptr::NonNull<T>;
         let mut _12: usize;
+        let _14: &T;
         scope 2 {
             let _3: *const T;
             scope 3 {
@@ -41,6 +42,13 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
                     scope 15 (inlined NonNull::<T>::as_ptr) {
                     }
                 }
+                scope 16 (inlined NonNull::<T>::as_ref::<'_>) {
+                    let _13: *const T;
+                    scope 17 (inlined NonNull::<T>::as_ptr) {
+                    }
+                    scope 18 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
+                    }
+                }
             }
         }
     }
@@ -51,6 +59,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         StorageLive(_11);
         StorageLive(_12);
         StorageLive(_4);
+        StorageLive(_14);
         _2 = copy ((*_1).0: std::ptr::NonNull<T>);
         _3 = copy ((*_1).1: *const T);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb4];
@@ -107,11 +116,16 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
     }
 
     bb7: {
-        _0 = copy _2 as std::option::Option<&T> (Transmute);
+        StorageLive(_13);
+        _13 = copy _2 as *const T (Transmute);
+        _14 = &(*_13);
+        StorageDead(_13);
+        _0 = Option::<&T>::Some(copy _14);
         goto -> bb8;
     }
 
     bb8: {
+        StorageDead(_14);
         StorageDead(_4);
         StorageDead(_12);
         StorageDead(_11);