Merge from rustc

16 files changed, 336 insertions, 104 deletions

diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir
index cfb9134a1f1..e31a8cb6937 100644
--- a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir
@@ -4,12 +4,87 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     debug x => _1;
     debug n => _2;
     let mut _0: u16;
+    scope 1 (inlined <u16 as Step>::forward) {
+        let mut _8: u16;
+        scope 2 {
+        }
+        scope 3 (inlined <u16 as Step>::forward_checked) {
+            scope 4 {
+                scope 6 (inlined core::num::<impl u16>::checked_add) {
+                    let mut _7: bool;
+                    scope 7 {
+                    }
+                    scope 8 (inlined core::num::<impl u16>::overflowing_add) {
+                        let mut _5: (u16, bool);
+                        let _6: bool;
+                        scope 9 {
+                        }
+                    }
+                }
+            }
+            scope 5 (inlined convert::num::ptr_try_from_impls::<impl TryFrom<usize> for u16>::try_from) {
+                let mut _3: bool;
+                let mut _4: u16;
+            }
+        }
+        scope 10 (inlined Option::<u16>::is_none) {
+            scope 11 (inlined Option::<u16>::is_some) {
+            }
+        }
+        scope 12 (inlined core::num::<impl u16>::wrapping_add) {
+        }
+    }
 
     bb0: {
-        _0 = <u16 as Step>::forward(move _1, move _2) -> [return: bb1, unwind unreachable];
+        StorageLive(_4);
+        StorageLive(_3);
+        _3 = Gt(_2, const 65535_usize);
+        switchInt(move _3) -> [0: bb1, otherwise: bb5];
     }
 
     bb1: {
+        _4 = _2 as u16 (IntToInt);
+        StorageDead(_3);
+        StorageLive(_6);
+        StorageLive(_5);
+        _5 = AddWithOverflow(_1, _4);
+        _6 = (_5.1: bool);
+        StorageDead(_5);
+        StorageLive(_7);
+        _7 = unlikely(move _6) -> [return: bb2, unwind unreachable];
+    }
+
+    bb2: {
+        switchInt(move _7) -> [0: bb3, otherwise: bb4];
+    }
+
+    bb3: {
+        StorageDead(_7);
+        StorageDead(_6);
+        goto -> bb7;
+    }
+
+    bb4: {
+        StorageDead(_7);
+        StorageDead(_6);
+        goto -> bb6;
+    }
+
+    bb5: {
+        StorageDead(_3);
+        goto -> bb6;
+    }
+
+    bb6: {
+        assert(!const true, "attempt to compute `{} + {}`, which would overflow", const core::num::<impl u16>::MAX, const 1_u16) -> [success: bb7, unwind unreachable];
+    }
+
+    bb7: {
+        StorageLive(_8);
+        _8 = _2 as u16 (IntToInt);
+        _0 = Add(_1, _8);
+        StorageDead(_8);
+        StorageDead(_4);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir
index cacc1224aba..8cc9be27e21 100644
--- a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir
@@ -4,12 +4,87 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     debug x => _1;
     debug n => _2;
     let mut _0: u16;
+    scope 1 (inlined <u16 as Step>::forward) {
+        let mut _8: u16;
+        scope 2 {
+        }
+        scope 3 (inlined <u16 as Step>::forward_checked) {
+            scope 4 {
+                scope 6 (inlined core::num::<impl u16>::checked_add) {
+                    let mut _7: bool;
+                    scope 7 {
+                    }
+                    scope 8 (inlined core::num::<impl u16>::overflowing_add) {
+                        let mut _5: (u16, bool);
+                        let _6: bool;
+                        scope 9 {
+                        }
+                    }
+                }
+            }
+            scope 5 (inlined convert::num::ptr_try_from_impls::<impl TryFrom<usize> for u16>::try_from) {
+                let mut _3: bool;
+                let mut _4: u16;
+            }
+        }
+        scope 10 (inlined Option::<u16>::is_none) {
+            scope 11 (inlined Option::<u16>::is_some) {
+            }
+        }
+        scope 12 (inlined core::num::<impl u16>::wrapping_add) {
+        }
+    }
 
     bb0: {
-        _0 = <u16 as Step>::forward(move _1, move _2) -> [return: bb1, unwind continue];
+        StorageLive(_4);
+        StorageLive(_3);
+        _3 = Gt(_2, const 65535_usize);
+        switchInt(move _3) -> [0: bb1, otherwise: bb5];
     }
 
     bb1: {
+        _4 = _2 as u16 (IntToInt);
+        StorageDead(_3);
+        StorageLive(_6);
+        StorageLive(_5);
+        _5 = AddWithOverflow(_1, _4);
+        _6 = (_5.1: bool);
+        StorageDead(_5);
+        StorageLive(_7);
+        _7 = unlikely(move _6) -> [return: bb2, unwind unreachable];
+    }
+
+    bb2: {
+        switchInt(move _7) -> [0: bb3, otherwise: bb4];
+    }
+
+    bb3: {
+        StorageDead(_7);
+        StorageDead(_6);
+        goto -> bb7;
+    }
+
+    bb4: {
+        StorageDead(_7);
+        StorageDead(_6);
+        goto -> bb6;
+    }
+
+    bb5: {
+        StorageDead(_3);
+        goto -> bb6;
+    }
+
+    bb6: {
+        assert(!const true, "attempt to compute `{} + {}`, which would overflow", const core::num::<impl u16>::MAX, const 1_u16) -> [success: bb7, unwind continue];
+    }
+
+    bb7: {
+        StorageLive(_8);
+        _8 = _2 as u16 (IntToInt);
+        _0 = Add(_1, _8);
+        StorageDead(_8);
+        StorageDead(_4);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir
index b800a1be22b..51d41e9ff05 100644
--- a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir
@@ -7,14 +7,30 @@ fn mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> U) -> () {
     let mut _3: std::iter::Map<impl Iterator<Item = T>, impl Fn(T) -> U>;
     let mut _4: std::iter::Map<impl Iterator<Item = T>, impl Fn(T) -> U>;
     let mut _5: &mut std::iter::Map<impl Iterator<Item = T>, impl Fn(T) -> U>;
-    let mut _6: std::option::Option<U>;
-    let mut _7: isize;
-    let _9: ();
+    let mut _13: std::option::Option<U>;
+    let _15: ();
     scope 1 {
         debug iter => _4;
-        let _8: U;
+        let _14: U;
         scope 2 {
-            debug x => _8;
+            debug x => _14;
+        }
+        scope 4 (inlined <Map<impl Iterator<Item = T>, impl Fn(T) -> U> as Iterator>::next) {
+            debug self => _5;
+            let mut _6: &mut impl Iterator<Item = T>;
+            let mut _7: std::option::Option<T>;
+            let mut _8: &mut impl Fn(T) -> U;
+            scope 5 (inlined Option::<T>::map::<U, &mut impl Fn(T) -> U>) {
+                debug self => _7;
+                debug f => _8;
+                let mut _9: isize;
+                let _10: T;
+                let mut _11: (T,);
+                let mut _12: U;
+                scope 6 {
+                    debug x => _10;
+                }
+            }
         }
     }
     scope 3 (inlined <Map<impl Iterator<Item = T>, impl Fn(T) -> U> as IntoIterator>::into_iter) {
@@ -32,20 +48,30 @@ fn mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> U) -> () {
     }
 
     bb2: {
-        StorageLive(_6);
-        StorageLive(_5);
+        StorageLive(_13);
         _5 = &mut _4;
-        _6 = <Map<impl Iterator<Item = T>, impl Fn(T) -> U> as Iterator>::next(move _5) -> [return: bb3, unwind: bb9];
+        StorageLive(_8);
+        StorageLive(_7);
+        StorageLive(_6);
+        _6 = &mut (_4.0: impl Iterator<Item = T>);
+        _7 = <impl Iterator<Item = T> as Iterator>::next(move _6) -> [return: bb3, unwind: bb10];
     }
 
     bb3: {
-        StorageDead(_5);
-        _7 = discriminant(_6);
-        switchInt(move _7) -> [0: bb4, 1: bb6, otherwise: bb8];
+        StorageDead(_6);
+        _8 = &mut (_4.1: impl Fn(T) -> U);
+        StorageLive(_9);
+        StorageLive(_10);
+        _9 = discriminant(_7);
+        switchInt(move _9) -> [0: bb4, 1: bb6, otherwise: bb9];
     }
 
     bb4: {
-        StorageDead(_6);
+        StorageDead(_10);
+        StorageDead(_9);
+        StorageDead(_7);
+        StorageDead(_8);
+        StorageDead(_13);
         drop(_4) -> [return: bb5, unwind continue];
     }
 
@@ -55,24 +81,39 @@ fn mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> U) -> () {
     }
 
     bb6: {
-        _8 = move ((_6 as Some).0: U);
-        _9 = opaque::<U>(move _8) -> [return: bb7, unwind: bb9];
+        _10 = move ((_7 as Some).0: T);
+        StorageLive(_12);
+        StorageLive(_11);
+        _11 = (_10,);
+        _12 = <&mut impl Fn(T) -> U as FnOnce<(T,)>>::call_once(move _8, move _11) -> [return: bb7, unwind: bb10];
     }
 
     bb7: {
-        StorageDead(_6);
-        goto -> bb2;
+        StorageDead(_11);
+        _13 = Option::<U>::Some(move _12);
+        StorageDead(_12);
+        StorageDead(_10);
+        StorageDead(_9);
+        StorageDead(_7);
+        StorageDead(_8);
+        _14 = move ((_13 as Some).0: U);
+        _15 = opaque::<U>(move _14) -> [return: bb8, unwind: bb10];
     }
 
     bb8: {
-        unreachable;
+        StorageDead(_13);
+        goto -> bb2;
     }
 
-    bb9 (cleanup): {
-        drop(_4) -> [return: bb10, unwind terminate(cleanup)];
+    bb9: {
+        unreachable;
     }
 
     bb10 (cleanup): {
+        drop(_4) -> [return: bb11, unwind terminate(cleanup)];
+    }
+
+    bb11 (cleanup): {
         resume;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/slice_index.rs b/tests/mir-opt/pre-codegen/slice_index.rs
index 886e57a3380..6ddc4ad0220 100644
--- a/tests/mir-opt/pre-codegen/slice_index.rs
+++ b/tests/mir-opt/pre-codegen/slice_index.rs
@@ -19,7 +19,7 @@ pub fn slice_index_usize(slice: &[u32], index: usize) -> u32 {
 // EMIT_MIR slice_index.slice_get_mut_usize.PreCodegen.after.mir
 pub fn slice_get_mut_usize(slice: &mut [u32], index: usize) -> Option<&mut u32> {
     // CHECK-LABEL: slice_get_mut_usize
-    // CHECK: [[LEN:_[0-9]+]] = Len((*_1))
+    // CHECK: [[LEN:_[0-9]+]] = PtrMetadata(_1)
     // CHECK: Lt(_2, move [[LEN]])
     // CHECK-NOT: precondition_check
     slice.get_mut(index)
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir
index f2ef2b0cc3c..d7f09fafeeb 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir
@@ -23,7 +23,7 @@ fn slice_get_mut_usize(_1: &mut [u32], _2: usize) -> Option<&mut u32> {
         StorageLive(_7);
         StorageLive(_4);
         StorageLive(_3);
-        _3 = Len((*_1));
+        _3 = PtrMetadata(_1);
         _4 = Lt(_2, move _3);
         switchInt(move _4) -> [0: bb1, otherwise: bb2];
     }
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir
index f2ef2b0cc3c..d7f09fafeeb 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir
@@ -23,7 +23,7 @@ fn slice_get_mut_usize(_1: &mut [u32], _2: usize) -> Option<&mut u32> {
         StorageLive(_7);
         StorageLive(_4);
         StorageLive(_3);
-        _3 = Len((*_1));
+        _3 = PtrMetadata(_1);
         _4 = Lt(_2, move _3);
         switchInt(move _4) -> [0: bb1, otherwise: bb2];
     }
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir
index 5e0398d1114..2f13cfa4dab 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir
@@ -8,25 +8,24 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range<usize>) ->
     let mut _4: usize;
     scope 1 (inlined core::slice::<impl [u32]>::get_unchecked_mut::<std::ops::Range<usize>>) {
         let mut _5: *mut [u32];
-        let mut _12: *mut [u32];
+        let mut _11: *mut [u32];
         scope 2 (inlined <std::ops::Range<usize> as SliceIndex<[u32]>>::get_unchecked_mut) {
-            let mut _7: usize;
-            let _8: ();
-            let _9: usize;
+            let mut _6: usize;
+            let _7: ();
+            let _8: usize;
             scope 3 {
                 scope 6 (inlined core::slice::index::get_offset_len_mut_noubcheck::<u32>) {
-                    let _11: *mut u32;
+                    let _10: *mut u32;
                     scope 7 {
                     }
                     scope 8 (inlined core::slice::index::get_mut_noubcheck::<u32>) {
-                        let _10: *mut u32;
+                        let _9: *mut u32;
                         scope 9 {
                         }
                     }
                 }
             }
             scope 4 (inlined std::ptr::mut_ptr::<impl *mut [u32]>::len) {
-                let mut _6: *const [u32];
                 scope 5 (inlined std::ptr::metadata::<[u32]>) {
                 }
             }
@@ -38,28 +37,25 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range<usize>) ->
         _4 = move (_2.1: usize);
         StorageLive(_5);
         _5 = &raw mut (*_1);
-        StorageLive(_9);
-        StorageLive(_7);
+        StorageLive(_8);
         StorageLive(_6);
-        _6 = _5 as *const [u32] (PointerCoercion(MutToConstPointer));
-        _7 = PtrMetadata(_6);
-        StorageDead(_6);
-        _8 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(_3, _4, move _7) -> [return: bb1, unwind unreachable];
+        _6 = PtrMetadata(_1);
+        _7 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(_3, _4, move _6) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
-        StorageDead(_7);
-        _9 = SubUnchecked(_4, _3);
-        StorageLive(_11);
+        StorageDead(_6);
+        _8 = SubUnchecked(_4, _3);
         StorageLive(_10);
-        _10 = _5 as *mut u32 (PtrToPtr);
-        _11 = Offset(_10, _3);
-        StorageDead(_10);
-        _12 = *mut [u32] from (_11, _9);
-        StorageDead(_11);
+        StorageLive(_9);
+        _9 = _5 as *mut u32 (PtrToPtr);
+        _10 = Offset(_9, _3);
         StorageDead(_9);
+        _11 = *mut [u32] from (_10, _8);
+        StorageDead(_10);
+        StorageDead(_8);
         StorageDead(_5);
-        _0 = &mut (*_12);
+        _0 = &mut (*_11);
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir
index 5e0398d1114..2f13cfa4dab 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir
@@ -8,25 +8,24 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range<usize>) ->
     let mut _4: usize;
     scope 1 (inlined core::slice::<impl [u32]>::get_unchecked_mut::<std::ops::Range<usize>>) {
         let mut _5: *mut [u32];
-        let mut _12: *mut [u32];
+        let mut _11: *mut [u32];
         scope 2 (inlined <std::ops::Range<usize> as SliceIndex<[u32]>>::get_unchecked_mut) {
-            let mut _7: usize;
-            let _8: ();
-            let _9: usize;
+            let mut _6: usize;
+            let _7: ();
+            let _8: usize;
             scope 3 {
                 scope 6 (inlined core::slice::index::get_offset_len_mut_noubcheck::<u32>) {
-                    let _11: *mut u32;
+                    let _10: *mut u32;
                     scope 7 {
                     }
                     scope 8 (inlined core::slice::index::get_mut_noubcheck::<u32>) {
-                        let _10: *mut u32;
+                        let _9: *mut u32;
                         scope 9 {
                         }
                     }
                 }
             }
             scope 4 (inlined std::ptr::mut_ptr::<impl *mut [u32]>::len) {
-                let mut _6: *const [u32];
                 scope 5 (inlined std::ptr::metadata::<[u32]>) {
                 }
             }
@@ -38,28 +37,25 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range<usize>) ->
         _4 = move (_2.1: usize);
         StorageLive(_5);
         _5 = &raw mut (*_1);
-        StorageLive(_9);
-        StorageLive(_7);
+        StorageLive(_8);
         StorageLive(_6);
-        _6 = _5 as *const [u32] (PointerCoercion(MutToConstPointer));
-        _7 = PtrMetadata(_6);
-        StorageDead(_6);
-        _8 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(_3, _4, move _7) -> [return: bb1, unwind unreachable];
+        _6 = PtrMetadata(_1);
+        _7 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(_3, _4, move _6) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
-        StorageDead(_7);
-        _9 = SubUnchecked(_4, _3);
-        StorageLive(_11);
+        StorageDead(_6);
+        _8 = SubUnchecked(_4, _3);
         StorageLive(_10);
-        _10 = _5 as *mut u32 (PtrToPtr);
-        _11 = Offset(_10, _3);
-        StorageDead(_10);
-        _12 = *mut [u32] from (_11, _9);
-        StorageDead(_11);
+        StorageLive(_9);
+        _9 = _5 as *mut u32 (PtrToPtr);
+        _10 = Offset(_9, _3);
         StorageDead(_9);
+        _11 = *mut [u32] from (_10, _8);
+        StorageDead(_10);
+        StorageDead(_8);
         StorageDead(_5);
-        _0 = &mut (*_12);
+        _0 = &mut (*_11);
         return;
     }
 }
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 8f41fb70925..953e7550479 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,19 +7,44 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &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: &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: ();
+    let mut _21: std::option::Option<(usize, &T)>;
+    let mut _24: &impl Fn(usize, &T);
+    let mut _25: (usize, &T);
+    let _26: ();
     scope 1 {
         debug iter => _13;
-        let _17: usize;
-        let _18: &T;
+        let _22: usize;
+        let _23: &T;
         scope 2 {
-            debug i => _17;
-            debug x => _18;
+            debug i => _22;
+            debug x => _23;
+        }
+        scope 17 (inlined <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next) {
+            let mut _14: &mut std::slice::Iter<'_, T>;
+            let mut _15: std::option::Option<&T>;
+            let mut _19: (usize, bool);
+            let mut _20: (usize, &T);
+            scope 18 {
+                let _18: usize;
+                scope 23 {
+                }
+            }
+            scope 19 {
+                scope 20 {
+                    scope 26 (inlined <Option<(usize, &T)> as FromResidual>::from_residual) {
+                    }
+                }
+            }
+            scope 21 {
+                scope 22 {
+                }
+            }
+            scope 24 (inlined <Option<&T> as Try>::branch) {
+                let mut _16: isize;
+                let _17: &T;
+                scope 25 {
+                }
+            }
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
@@ -65,7 +90,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = Len((*_1));
+        _3 = PtrMetadata(_1);
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
@@ -79,7 +104,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }
@@ -107,20 +132,28 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb4: {
+        StorageLive(_21);
+        StorageLive(_18);
+        StorageLive(_19);
         StorageLive(_15);
         StorageLive(_14);
-        _14 = &mut _13;
-        _15 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _14) -> [return: bb5, unwind unreachable];
+        _14 = &mut (_13.0: std::slice::Iter<'_, T>);
+        _15 = <std::slice::Iter<'_, T> as Iterator>::next(move _14) -> [return: bb5, unwind unreachable];
     }
 
     bb5: {
         StorageDead(_14);
+        StorageLive(_16);
         _16 = discriminant(_15);
-        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb10];
+        switchInt(move _16) -> [0: bb6, 1: bb8, otherwise: bb11];
     }
 
     bb6: {
+        StorageDead(_16);
         StorageDead(_15);
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageDead(_21);
         StorageDead(_13);
         drop(_2) -> [return: bb7, unwind unreachable];
     }
@@ -130,23 +163,39 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb8: {
-        _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 = (_17, _18);
-        _21 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _19, move _20) -> [return: bb9, unwind unreachable];
+        _17 = move ((_15 as Some).0: &T);
+        StorageDead(_16);
+        StorageDead(_15);
+        _18 = (_13.1: usize);
+        _19 = AddWithOverflow((_13.1: usize), const 1_usize);
+        assert(!move (_19.1: bool), "attempt to compute `{} + {}`, which would overflow", (_13.1: usize), const 1_usize) -> [success: bb9, unwind unreachable];
     }
 
     bb9: {
+        (_13.1: usize) = move (_19.0: usize);
+        StorageLive(_20);
+        _20 = (_18, _17);
+        _21 = Option::<(usize, &T)>::Some(move _20);
         StorageDead(_20);
         StorageDead(_19);
-        StorageDead(_15);
-        goto -> bb4;
+        StorageDead(_18);
+        _22 = (((_21 as Some).0: (usize, &T)).0: usize);
+        _23 = (((_21 as Some).0: (usize, &T)).1: &T);
+        StorageLive(_24);
+        _24 = &_2;
+        StorageLive(_25);
+        _25 = (_22, _23);
+        _26 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _24, move _25) -> [return: bb10, unwind unreachable];
     }
 
     bb10: {
+        StorageDead(_25);
+        StorageDead(_24);
+        StorageDead(_21);
+        goto -> bb4;
+    }
+
+    bb11: {
         unreachable;
     }
 }
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 17cf305468e..d5fdb2e08cc 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
@@ -65,7 +65,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = Len((*_1));
+        _3 = PtrMetadata(_1);
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
@@ -79,7 +79,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }
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 3c1bbdc8742..cc2beac06f2 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
@@ -57,7 +57,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = Len((*_1));
+        _3 = PtrMetadata(_1);
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
@@ -71,7 +71,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }
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 b2ec1ea7b9f..d66edb28570 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
@@ -57,7 +57,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = Len((*_1));
+        _3 = PtrMetadata(_1);
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
@@ -71,7 +71,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }
diff --git a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir
index dbe6f39548c..cea2fcbcdc0 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir
@@ -40,7 +40,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb0: {
-        _3 = Len((*_1));
+        _3 = PtrMetadata(_1);
         StorageLive(_4);
         _4 = const 0_usize;
         goto -> bb1;
diff --git a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir
index 5b6441cfb3b..bd658a770ea 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir
@@ -40,7 +40,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb0: {
-        _3 = Len((*_1));
+        _3 = PtrMetadata(_1);
         StorageLive(_4);
         _4 = const 0_usize;
         goto -> bb1;
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 bf982f076de..fbb887fe76a 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
@@ -65,7 +65,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = Len((*_1));
+        _3 = PtrMetadata(_1);
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
@@ -79,7 +79,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }
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 532b8162521..db9409f72ab 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
@@ -65,7 +65,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = Len((*_1));
+        _3 = PtrMetadata(_1);
         _4 = &raw const (*_1);
         _5 = _4 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: _5 };
@@ -79,7 +79,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }