Optimize Ref<_, T> methods when T: Sized (#2752)

With optimization:
test r#ref::tests::bench_from_bytes_sized ... bench:           4.86 ns/iter (+/- 0.33)
test r#ref::tests::bench_into_ref_sized   ... bench:           0.88 ns/iter (+/- 0.05)

Without optimization:
test r#ref::tests::bench_from_bytes_sized ... bench:           5.03 ns/iter (+/- 0.60)
test r#ref::tests::bench_into_ref_sized   ... bench:           0.89 ns/iter (+/- 0.12)

Closes #2752

Co-authored-by: Joshua Liebow-Feeser <[email protected]>

Author: bmberger

src/ref.rs

@@ -192,6 +192,9 @@ mod def {
 
 #[allow(unreachable_pub)] // This is a false positive on our MSRV toolchain.
 pub use def::Ref;
+use crate::pointer::invariant::{
+    Aligned, Initialized, Shared, Valid, Unaligned,
+};
 
 impl<B, T> Ref<B, T>
 where
@@ -620,30 +623,21 @@ where
 
         if let crate::layout::SizeInfo::Sized { .. } = T::LAYOUT.size_info {
             let ptr = Ptr::from_ref(b);
-            // SAFETY: `T::raw_from_ptr_len` promises to preserve address and provenance in the referent
-            let ptr: Ptr<'_, T, _> = unsafe {
-                ptr.transmute_unchecked(|ptr| {
+            let ptr: Ptr<'_, [u8], (Shared, Unaligned, Initialized)> = ptr.transmute::<_, _, (_, (_, _))>();
+            // SAFETY: `T::raw_from_ptr_len` promises to preserve address and provenance in the referent.
+            let ptr: Ptr<'_, T, (Shared, Unaligned, Initialized)> = unsafe {
+                ptr.cast_unsized(|ptr| {
                     let ptr = T::raw_from_ptr_len(
                         ptr.as_non_null().cast(),
                         <T::PointerMetadata as crate::PointerMetadata>::from_elem_count(0),
                     );
-                    // SAFETY: The safety invariants of `Ptr::new` (see definition) are
-                    // satisfied:
-                    // 0. If `ptr`'s referent is not zero sized, then `ptr` has valid
-                    //    provenance for its referent, because it derived from `self`
-                    //    using a series of provenance-preserving operations, and
-                    //    because `self` has valid provenance for its referent. By the
-                    //    same argument, `ptr`'s referent is entirely contained within
-                    //    the same allocated object as `self`'s referent.
-                    // 1. If `ptr`'s referent is not zero sized, then the allocation of
-                    //    `ptr` is guaranteed to live for at least `'a`, because `ptr`
-                    //    is entirely contained in `self`, which lives for at least `'a`
-                    //    by invariant on `Ptr`.
                     unsafe { crate::pointer::PtrInner::new(ptr) }
                 })
             };
-            // SAFETY: By invariant on `r`, we know that size and alignment are valid.
-            let ptr = unsafe { ptr.assume_alignment() };
+
+            // SAFETY: By invariant on `r`, we know that alignment is valid.
+            let ptr = unsafe { ptr.assume_alignment::<Aligned>() };
+            let ptr = ptr.recall_validity::<Valid, _>();
             return ptr.as_ref();
         }
 
@@ -1005,39 +999,44 @@ mod tests {
     fn bench_from_bytes_sized(b: &mut Bencher) {
         let buf = Align::<[u8; 8], AU64>::default();
         // `buf.t` should be aligned to 8, so this should always succeed.
-        b.iter(|| test::black_box(Ref::<_, AU64>::from_bytes(&buf.t[..]).unwrap()));
+        let bytes = &buf.t[..];
+        b.iter(|| test::black_box(Ref::<_, AU64>::from_bytes(test::black_box(bytes)).unwrap()));
     }
 
     #[bench]
     fn bench_into_ref_sized(b: &mut Bencher) {
         let buf = Align::<[u8; 8], AU64>::default();
+        let bytes = &buf.t[..];
         b.iter(|| {
-            let r = Ref::<_, AU64>::from_bytes(&buf.t[..]).unwrap();
+            let r = Ref::<_, AU64>::from_bytes(test::black_box(bytes)).unwrap();
             test::black_box(Ref::into_ref(r))
         });
     }
 
     #[bench]
     fn bench_into_mut_sized(b: &mut Bencher) {
         let mut buf = Align::<[u8; 8], AU64>::default();
+        // TODO change these
         b.iter(|| {
-            let r = Ref::<_, AU64>::from_bytes(&mut buf.t[..]).unwrap();
+            let r = Ref::<_, AU64>::from_bytes(test::black_box(&mut buf.t[..])).unwrap();
             test::black_box(Ref::into_mut(r));
         });
     }
 
     #[bench]
     fn bench_deref_sized(b: &mut Bencher) {
         let buf = Align::<[u8; 8], AU64>::default();
-        let r = Ref::<_, AU64>::from_bytes(&buf.t[..]).unwrap();
+        let bytes = &buf.t[..];
+        let r = Ref::<_, AU64>::from_bytes(test::black_box(bytes)).unwrap();
         b.iter(|| test::black_box(r.deref()));
     }
 
     #[bench]
     fn bench_deref_mut_sized(b: &mut Bencher) {
         let mut buf = Align::<[u8; 8], AU64>::default();
+        // TODO change these
         b.iter(|| {
-            let mut r = Ref::<_, AU64>::from_bytes(&mut buf.t[..]).unwrap();
+            let mut r = Ref::<_, AU64>::from_bytes(test::black_box(&mut buf.t[..])).unwrap();
             test::black_box(r.deref_mut());
         });
     }