Add 'from_ref' and 'from_mut' constructors to 'core::ptr::NonNull';

bjoernager · bjoernager · commit 94ab726c7856 · 2024-09-27T13:39:08.000+02:00
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
@@ -174,6 +174,7 @@
 #![feature(isqrt)]
 #![feature(lazy_get)]
 #![feature(link_cfg)]
+#![feature(non_null_from_ref)]
 #![feature(offset_of_enum)]
 #![feature(panic_internals)]
 #![feature(ptr_alignment_type)]
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
@@ -230,6 +230,24 @@ impl<T: ?Sized> NonNull<T> {
         }
     }
 
+    /// Converts a reference to a `NonNull` pointer.
+    #[unstable(feature = "non_null_from_ref", issue = "130823")]
+    #[rustc_const_unstable(feature = "non_null_from_ref", issue = "130823")]
+    #[inline]
+    pub const fn from_ref(r: &T) -> Self {
+        // SAFETY: A reference cannot be null.
+        unsafe { NonNull { pointer: r as *const T } }
+    }
+
+    /// Converts a mutable reference to a `NonNull` pointer.
+    #[unstable(feature = "non_null_from_ref", issue = "130823")]
+    #[rustc_const_unstable(feature = "non_null_from_ref", issue = "130823")]
+    #[inline]
+    pub const fn from_mut(r: &mut T) -> Self {
+        // SAFETY: A mutable reference cannot be null.
+        unsafe { NonNull { pointer: r as *mut T } }
+    }
+
     /// Performs the same functionality as [`std::ptr::from_raw_parts`], except that a
     /// `NonNull` pointer is returned, as opposed to a raw `*const` pointer.
     ///
@@ -1753,9 +1771,8 @@ impl<T: ?Sized> From<&mut T> for NonNull<T> {
     ///
     /// This conversion is safe and infallible since references cannot be null.
     #[inline]
-    fn from(reference: &mut T) -> Self {
-        // SAFETY: A mutable reference cannot be null.
-        unsafe { NonNull { pointer: reference as *mut T } }
+    fn from(r: &mut T) -> Self {
+        NonNull::from_mut(r)
     }
 }
 
@@ -1765,8 +1782,7 @@ impl<T: ?Sized> From<&T> for NonNull<T> {
     ///
     /// This conversion is safe and infallible since references cannot be null.
     #[inline]
-    fn from(reference: &T) -> Self {
-        // SAFETY: A reference cannot be null.
-        unsafe { NonNull { pointer: reference as *const T } }
+    fn from(r: &T) -> Self {
+        NonNull::from_ref(r)
     }
 }
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
@@ -19,30 +19,30 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
             debug i => _22;
             debug x => _23;
         }
-        scope 17 (inlined <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next) {
+        scope 18 (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 {
+            scope 19 {
                 let _18: usize;
-                scope 23 {
+                scope 24 {
                 }
             }
-            scope 19 {
-                scope 20 {
-                    scope 26 (inlined <Option<(usize, &T)> as FromResidual<Option<Infallible>>>::from_residual) {
+            scope 20 {
+                scope 21 {
+                    scope 27 (inlined <Option<(usize, &T)> as FromResidual<Option<Infallible>>>::from_residual) {
                     }
                 }
             }
-            scope 21 {
-                scope 22 {
+            scope 22 {
+                scope 23 {
                 }
             }
-            scope 24 (inlined <Option<&T> as Try>::branch) {
+            scope 25 (inlined <Option<&T> as Try>::branch) {
                 let mut _16: isize;
                 let _17: &T;
-                scope 25 {
+                scope 26 {
                 }
             }
         }
@@ -59,29 +59,31 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                     let _9: *const T;
                     scope 7 {
                     }
-                    scope 11 (inlined without_provenance::<T>) {
+                    scope 12 (inlined without_provenance::<T>) {
                     }
-                    scope 12 (inlined NonNull::<T>::as_ptr) {
+                    scope 13 (inlined NonNull::<T>::as_ptr) {
                     }
-                    scope 13 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
+                    scope 14 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
                     }
                 }
                 scope 8 (inlined <NonNull<[T]> as From<&[T]>>::from) {
-                    let mut _4: *const [T];
+                    scope 9 (inlined NonNull::<[T]>::from_ref) {
+                        let mut _4: *const [T];
+                    }
                 }
-                scope 9 (inlined NonNull::<[T]>::cast::<T>) {
+                scope 10 (inlined NonNull::<[T]>::cast::<T>) {
                     let mut _5: *const T;
-                    scope 10 (inlined NonNull::<[T]>::as_ptr) {
+                    scope 11 (inlined NonNull::<[T]>::as_ptr) {
                     }
                 }
             }
         }
     }
-    scope 14 (inlined <std::slice::Iter<'_, T> as Iterator>::enumerate) {
-        scope 15 (inlined Enumerate::<std::slice::Iter<'_, T>>::new) {
+    scope 15 (inlined <std::slice::Iter<'_, T> as Iterator>::enumerate) {
+        scope 16 (inlined Enumerate::<std::slice::Iter<'_, T>>::new) {
         }
     }
-    scope 16 (inlined <Enumerate<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {
+    scope 17 (inlined <Enumerate<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {
     }
 
     bb0: {
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
@@ -34,29 +34,31 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                     let _9: *const T;
                     scope 7 {
                     }
-                    scope 11 (inlined without_provenance::<T>) {
+                    scope 12 (inlined without_provenance::<T>) {
                     }
-                    scope 12 (inlined NonNull::<T>::as_ptr) {
+                    scope 13 (inlined NonNull::<T>::as_ptr) {
                     }
-                    scope 13 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
+                    scope 14 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
                     }
                 }
                 scope 8 (inlined <NonNull<[T]> as From<&[T]>>::from) {
-                    let mut _4: *const [T];
+                    scope 9 (inlined NonNull::<[T]>::from_ref) {
+                        let mut _4: *const [T];
+                    }
                 }
-                scope 9 (inlined NonNull::<[T]>::cast::<T>) {
+                scope 10 (inlined NonNull::<[T]>::cast::<T>) {
                     let mut _5: *const T;
-                    scope 10 (inlined NonNull::<[T]>::as_ptr) {
+                    scope 11 (inlined NonNull::<[T]>::as_ptr) {
                     }
                 }
             }
         }
     }
-    scope 14 (inlined <std::slice::Iter<'_, T> as Iterator>::enumerate) {
-        scope 15 (inlined Enumerate::<std::slice::Iter<'_, T>>::new) {
+    scope 15 (inlined <std::slice::Iter<'_, T> as Iterator>::enumerate) {
+        scope 16 (inlined Enumerate::<std::slice::Iter<'_, T>>::new) {
         }
     }
-    scope 16 (inlined <Enumerate<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {
+    scope 17 (inlined <Enumerate<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {
     }
 
     bb0: {
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
@@ -31,25 +31,27 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                     let _9: *const T;
                     scope 7 {
                     }
-                    scope 11 (inlined without_provenance::<T>) {
+                    scope 12 (inlined without_provenance::<T>) {
                     }
-                    scope 12 (inlined NonNull::<T>::as_ptr) {
+                    scope 13 (inlined NonNull::<T>::as_ptr) {
                     }
-                    scope 13 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
+                    scope 14 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
                     }
                 }
                 scope 8 (inlined <NonNull<[T]> as From<&[T]>>::from) {
-                    let mut _4: *const [T];
+                    scope 9 (inlined NonNull::<[T]>::from_ref) {
+                        let mut _4: *const [T];
+                    }
                 }
-                scope 9 (inlined NonNull::<[T]>::cast::<T>) {
+                scope 10 (inlined NonNull::<[T]>::cast::<T>) {
                     let mut _5: *const T;
-                    scope 10 (inlined NonNull::<[T]>::as_ptr) {
+                    scope 11 (inlined NonNull::<[T]>::as_ptr) {
                     }
                 }
             }
         }
     }
-    scope 14 (inlined <std::slice::Iter<'_, T> as IntoIterator>::into_iter) {
+    scope 15 (inlined <std::slice::Iter<'_, T> as IntoIterator>::into_iter) {
     }
 
     bb0: {
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
@@ -31,25 +31,27 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                     let _9: *const T;
                     scope 7 {
                     }
-                    scope 11 (inlined without_provenance::<T>) {
+                    scope 12 (inlined without_provenance::<T>) {
                     }
-                    scope 12 (inlined NonNull::<T>::as_ptr) {
+                    scope 13 (inlined NonNull::<T>::as_ptr) {
                     }
-                    scope 13 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
+                    scope 14 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
                     }
                 }
                 scope 8 (inlined <NonNull<[T]> as From<&[T]>>::from) {
-                    let mut _4: *const [T];
+                    scope 9 (inlined NonNull::<[T]>::from_ref) {
+                        let mut _4: *const [T];
+                    }
                 }
-                scope 9 (inlined NonNull::<[T]>::cast::<T>) {
+                scope 10 (inlined NonNull::<[T]>::cast::<T>) {
                     let mut _5: *const T;
-                    scope 10 (inlined NonNull::<[T]>::as_ptr) {
+                    scope 11 (inlined NonNull::<[T]>::as_ptr) {
                     }
                 }
             }
         }
     }
-    scope 14 (inlined <std::slice::Iter<'_, T> as IntoIterator>::into_iter) {
+    scope 15 (inlined <std::slice::Iter<'_, T> as IntoIterator>::into_iter) {
     }
 
     bb0: {
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
@@ -18,7 +18,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         scope 2 {
             debug x => _17;
         }
-        scope 17 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
+        scope 18 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
             let mut _14: &mut std::slice::Iter<'_, T>;
         }
     }
@@ -34,29 +34,31 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                     let _9: *const T;
                     scope 7 {
                     }
-                    scope 11 (inlined without_provenance::<T>) {
+                    scope 12 (inlined without_provenance::<T>) {
                     }
-                    scope 12 (inlined NonNull::<T>::as_ptr) {
+                    scope 13 (inlined NonNull::<T>::as_ptr) {
                     }
-                    scope 13 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
+                    scope 14 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
                     }
                 }
                 scope 8 (inlined <NonNull<[T]> as From<&[T]>>::from) {
-                    let mut _4: *const [T];
+                    scope 9 (inlined NonNull::<[T]>::from_ref) {
+                        let mut _4: *const [T];
+                    }
                 }
-                scope 9 (inlined NonNull::<[T]>::cast::<T>) {
+                scope 10 (inlined NonNull::<[T]>::cast::<T>) {
                     let mut _5: *const T;
-                    scope 10 (inlined NonNull::<[T]>::as_ptr) {
+                    scope 11 (inlined NonNull::<[T]>::as_ptr) {
                     }
                 }
             }
         }
     }
-    scope 14 (inlined <std::slice::Iter<'_, T> as Iterator>::rev) {
-        scope 15 (inlined Rev::<std::slice::Iter<'_, T>>::new) {
+    scope 15 (inlined <std::slice::Iter<'_, T> as Iterator>::rev) {
+        scope 16 (inlined Rev::<std::slice::Iter<'_, T>>::new) {
         }
     }
-    scope 16 (inlined <Rev<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {
+    scope 17 (inlined <Rev<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {
     }
 
     bb0: {
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
@@ -18,7 +18,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         scope 2 {
             debug x => _17;
         }
-        scope 17 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
+        scope 18 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {
             let mut _14: &mut std::slice::Iter<'_, T>;
         }
     }
@@ -34,29 +34,31 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                     let _9: *const T;
                     scope 7 {
                     }
-                    scope 11 (inlined without_provenance::<T>) {
+                    scope 12 (inlined without_provenance::<T>) {
                     }
-                    scope 12 (inlined NonNull::<T>::as_ptr) {
+                    scope 13 (inlined NonNull::<T>::as_ptr) {
                     }
-                    scope 13 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
+                    scope 14 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {
                     }
                 }
                 scope 8 (inlined <NonNull<[T]> as From<&[T]>>::from) {
-                    let mut _4: *const [T];
+                    scope 9 (inlined NonNull::<[T]>::from_ref) {
+                        let mut _4: *const [T];
+                    }
                 }
-                scope 9 (inlined NonNull::<[T]>::cast::<T>) {
+                scope 10 (inlined NonNull::<[T]>::cast::<T>) {
                     let mut _5: *const T;
-                    scope 10 (inlined NonNull::<[T]>::as_ptr) {
+                    scope 11 (inlined NonNull::<[T]>::as_ptr) {
                     }
                 }
             }
         }
     }
-    scope 14 (inlined <std::slice::Iter<'_, T> as Iterator>::rev) {
-        scope 15 (inlined Rev::<std::slice::Iter<'_, T>>::new) {
+    scope 15 (inlined <std::slice::Iter<'_, T> as Iterator>::rev) {
+        scope 16 (inlined Rev::<std::slice::Iter<'_, T>>::new) {
         }
     }
-    scope 16 (inlined <Rev<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {
+    scope 17 (inlined <Rev<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {
     }
 
     bb0: {

Original file line number	Diff line number	Diff line change
`@@ -19,30 +19,30 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {`
`19`	`19`	`debug i => _22;`
`20`	`20`	`debug x => _23;`
`21`	`21`	`}`
`22`		`- scope 17 (inlined <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next) {`
	`22`	`+ scope 18 (inlined <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next) {`
`23`	`23`	`let mut _14: &mut std::slice::Iter<'_, T>;`
`24`	`24`	`let mut _15: std::option::Option<&T>;`
`25`	`25`	`let mut _19: (usize, bool);`
`26`	`26`	`let mut _20: (usize, &T);`
`27`		`- scope 18 {`
	`27`	`+ scope 19 {`
`28`	`28`	`let _18: usize;`
`29`		`- scope 23 {`
	`29`	`+ scope 24 {`
`30`	`30`	`}`
`31`	`31`	`}`
`32`		`- scope 19 {`
`33`		`- scope 20 {`
`34`		`- scope 26 (inlined <Option<(usize, &T)> as FromResidual<Option<Infallible>>>::from_residual) {`
	`32`	`+ scope 20 {`
	`33`	`+ scope 21 {`
	`34`	`+ scope 27 (inlined <Option<(usize, &T)> as FromResidual<Option<Infallible>>>::from_residual) {`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`	`}`
`38`		`- scope 21 {`
`39`		`- scope 22 {`
	`38`	`+ scope 22 {`
	`39`	`+ scope 23 {`
`40`	`40`	`}`
`41`	`41`	`}`
`42`		`- scope 24 (inlined <Option<&T> as Try>::branch) {`
	`42`	`+ scope 25 (inlined <Option<&T> as Try>::branch) {`
`43`	`43`	`let mut _16: isize;`
`44`	`44`	`let _17: &T;`
`45`		`- scope 25 {`
	`45`	`+ scope 26 {`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`	`}`
`@@ -59,29 +59,31 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {`
`59`	`59`	`let _9: *const T;`
`60`	`60`	`scope 7 {`
`61`	`61`	`}`
`62`		`- scope 11 (inlined without_provenance::<T>) {`
	`62`	`+ scope 12 (inlined without_provenance::<T>) {`
`63`	`63`	`}`
`64`		`- scope 12 (inlined NonNull::<T>::as_ptr) {`
	`64`	`+ scope 13 (inlined NonNull::<T>::as_ptr) {`
`65`	`65`	`}`
`66`		`- scope 13 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {`
	`66`	`+ scope 14 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`	`scope 8 (inlined <NonNull<[T]> as From<&[T]>>::from) {`
`70`		`- let mut _4: *const [T];`
	`70`	`+ scope 9 (inlined NonNull::<[T]>::from_ref) {`
	`71`	`+ let mut _4: *const [T];`
	`72`	`+ }`
`71`	`73`	`}`
`72`		`- scope 9 (inlined NonNull::<[T]>::cast::<T>) {`
	`74`	`+ scope 10 (inlined NonNull::<[T]>::cast::<T>) {`
`73`	`75`	`let mut _5: *const T;`
`74`		`- scope 10 (inlined NonNull::<[T]>::as_ptr) {`
	`76`	`+ scope 11 (inlined NonNull::<[T]>::as_ptr) {`
`75`	`77`	`}`
`76`	`78`	`}`
`77`	`79`	`}`
`78`	`80`	`}`
`79`	`81`	`}`
`80`		`- scope 14 (inlined <std::slice::Iter<'_, T> as Iterator>::enumerate) {`
`81`		`- scope 15 (inlined Enumerate::<std::slice::Iter<'_, T>>::new) {`
	`82`	`+ scope 15 (inlined <std::slice::Iter<'_, T> as Iterator>::enumerate) {`
	`83`	`+ scope 16 (inlined Enumerate::<std::slice::Iter<'_, T>>::new) {`
`82`	`84`	`}`
`83`	`85`	`}`
`84`		`- scope 16 (inlined <Enumerate<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {`
	`86`	`+ scope 17 (inlined <Enumerate<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {`
`85`	`87`	`}`
`86`	`88`
`87`	`89`	`bb0: {`
Original file line number	Diff line number	Diff line change
`@@ -34,29 +34,31 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {`
`34`	`34`	`let _9: *const T;`
`35`	`35`	`scope 7 {`
`36`	`36`	`}`
`37`		`- scope 11 (inlined without_provenance::<T>) {`
	`37`	`+ scope 12 (inlined without_provenance::<T>) {`
`38`	`38`	`}`
`39`		`- scope 12 (inlined NonNull::<T>::as_ptr) {`
	`39`	`+ scope 13 (inlined NonNull::<T>::as_ptr) {`
`40`	`40`	`}`
`41`		`- scope 13 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {`
	`41`	`+ scope 14 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`	`scope 8 (inlined <NonNull<[T]> as From<&[T]>>::from) {`
`45`		`- let mut _4: *const [T];`
	`45`	`+ scope 9 (inlined NonNull::<[T]>::from_ref) {`
	`46`	`+ let mut _4: *const [T];`
	`47`	`+ }`
`46`	`48`	`}`
`47`		`- scope 9 (inlined NonNull::<[T]>::cast::<T>) {`
	`49`	`+ scope 10 (inlined NonNull::<[T]>::cast::<T>) {`
`48`	`50`	`let mut _5: *const T;`
`49`		`- scope 10 (inlined NonNull::<[T]>::as_ptr) {`
	`51`	`+ scope 11 (inlined NonNull::<[T]>::as_ptr) {`
`50`	`52`	`}`
`51`	`53`	`}`
`52`	`54`	`}`
`53`	`55`	`}`
`54`	`56`	`}`
`55`		`- scope 14 (inlined <std::slice::Iter<'_, T> as Iterator>::enumerate) {`
`56`		`- scope 15 (inlined Enumerate::<std::slice::Iter<'_, T>>::new) {`
	`57`	`+ scope 15 (inlined <std::slice::Iter<'_, T> as Iterator>::enumerate) {`
	`58`	`+ scope 16 (inlined Enumerate::<std::slice::Iter<'_, T>>::new) {`
`57`	`59`	`}`
`58`	`60`	`}`
`59`		`- scope 16 (inlined <Enumerate<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {`
	`61`	`+ scope 17 (inlined <Enumerate<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {`
`60`	`62`	`}`
`61`	`63`
`62`	`64`	`bb0: {`
Original file line number	Diff line number	Diff line change
`@@ -31,25 +31,27 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {`
`31`	`31`	`let _9: *const T;`
`32`	`32`	`scope 7 {`
`33`	`33`	`}`
`34`		`- scope 11 (inlined without_provenance::<T>) {`
	`34`	`+ scope 12 (inlined without_provenance::<T>) {`
`35`	`35`	`}`
`36`		`- scope 12 (inlined NonNull::<T>::as_ptr) {`
	`36`	`+ scope 13 (inlined NonNull::<T>::as_ptr) {`
`37`	`37`	`}`
`38`		`- scope 13 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {`
	`38`	`+ scope 14 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`	`scope 8 (inlined <NonNull<[T]> as From<&[T]>>::from) {`
`42`		`- let mut _4: *const [T];`
	`42`	`+ scope 9 (inlined NonNull::<[T]>::from_ref) {`
	`43`	`+ let mut _4: *const [T];`
	`44`	`+ }`
`43`	`45`	`}`
`44`		`- scope 9 (inlined NonNull::<[T]>::cast::<T>) {`
	`46`	`+ scope 10 (inlined NonNull::<[T]>::cast::<T>) {`
`45`	`47`	`let mut _5: *const T;`
`46`		`- scope 10 (inlined NonNull::<[T]>::as_ptr) {`
	`48`	`+ scope 11 (inlined NonNull::<[T]>::as_ptr) {`
`47`	`49`	`}`
`48`	`50`	`}`
`49`	`51`	`}`
`50`	`52`	`}`
`51`	`53`	`}`
`52`		`- scope 14 (inlined <std::slice::Iter<'_, T> as IntoIterator>::into_iter) {`
	`54`	`+ scope 15 (inlined <std::slice::Iter<'_, T> as IntoIterator>::into_iter) {`
`53`	`55`	`}`
`54`	`56`
`55`	`57`	`bb0: {`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {`
`18`	`18`	`scope 2 {`
`19`	`19`	`debug x => _17;`
`20`	`20`	`}`
`21`		`- scope 17 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {`
	`21`	`+ scope 18 (inlined <Rev<std::slice::Iter<'_, T>> as Iterator>::next) {`
`22`	`22`	`let mut _14: &mut std::slice::Iter<'_, T>;`
`23`	`23`	`}`
`24`	`24`	`}`
`@@ -34,29 +34,31 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {`
`34`	`34`	`let _9: *const T;`
`35`	`35`	`scope 7 {`
`36`	`36`	`}`
`37`		`- scope 11 (inlined without_provenance::<T>) {`
	`37`	`+ scope 12 (inlined without_provenance::<T>) {`
`38`	`38`	`}`
`39`		`- scope 12 (inlined NonNull::<T>::as_ptr) {`
	`39`	`+ scope 13 (inlined NonNull::<T>::as_ptr) {`
`40`	`40`	`}`
`41`		`- scope 13 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {`
	`41`	`+ scope 14 (inlined std::ptr::mut_ptr::<impl *mut T>::add) {`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`	`scope 8 (inlined <NonNull<[T]> as From<&[T]>>::from) {`
`45`		`- let mut _4: *const [T];`
	`45`	`+ scope 9 (inlined NonNull::<[T]>::from_ref) {`
	`46`	`+ let mut _4: *const [T];`
	`47`	`+ }`
`46`	`48`	`}`
`47`		`- scope 9 (inlined NonNull::<[T]>::cast::<T>) {`
	`49`	`+ scope 10 (inlined NonNull::<[T]>::cast::<T>) {`
`48`	`50`	`let mut _5: *const T;`
`49`		`- scope 10 (inlined NonNull::<[T]>::as_ptr) {`
	`51`	`+ scope 11 (inlined NonNull::<[T]>::as_ptr) {`
`50`	`52`	`}`
`51`	`53`	`}`
`52`	`54`	`}`
`53`	`55`	`}`
`54`	`56`	`}`
`55`		`- scope 14 (inlined <std::slice::Iter<'_, T> as Iterator>::rev) {`
`56`		`- scope 15 (inlined Rev::<std::slice::Iter<'_, T>>::new) {`
	`57`	`+ scope 15 (inlined <std::slice::Iter<'_, T> as Iterator>::rev) {`
	`58`	`+ scope 16 (inlined Rev::<std::slice::Iter<'_, T>>::new) {`
`57`	`59`	`}`
`58`	`60`	`}`
`59`		`- scope 16 (inlined <Rev<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {`
	`61`	`+ scope 17 (inlined <Rev<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {`
`60`	`62`	`}`
`61`	`63`
`62`	`64`	`bb0: {`