Auto merge of rust-lang#117525 - GKFX:remove_option_payload_ptr, r=petrochenkov

Remove option_payload_ptr; redundant to offset_of

The `option_payload_ptr` intrinsic is no longer required as `offset_of` supports traversing enums (rust-lang#114208). This PR removes it in order to dogfood offset_of (as suggested at rust-lang#106655 (comment)). However, it will not build until those changes reach beta (which I think is within the next 8 days?) so I've opened it as a draft.

Author: bors

core/src/intrinsics.rs

@@ -2487,12 +2487,6 @@ extern "rust-intrinsic" {
     where
         G: FnOnce<ARG, Output = RET>,
         F: FnOnce<ARG, Output = RET>;
-
-    /// This method creates a pointer to any `Some` value. If the argument is
-    /// `None`, an invalid within-bounds pointer (that is still acceptable for
-    /// constructing an empty slice) is returned.
-    #[rustc_nounwind]
-    pub fn option_payload_ptr<T>(arg: *const Option<T>) -> *const T;
 }
 
 // Some functions are defined here because they accidentally got made

core/src/iter/adapters/filter_map.rs

@@ -97,9 +97,11 @@ where
             // SAFETY: Loop conditions ensure the index is in bounds.
 
             unsafe {
-                let opt_payload_at = core::intrinsics::option_payload_ptr(&val);
+                let opt_payload_at: *const MaybeUninit<B> = (&val as *const Option<B>)
+                    .byte_add(core::mem::offset_of!(Option<B>, Some.0))
+                    .cast();
                 let dst = guard.array.as_mut_ptr().add(idx);
-                crate::ptr::copy_nonoverlapping(opt_payload_at.cast(), dst, 1);
+                crate::ptr::copy_nonoverlapping(opt_payload_at, dst, 1);
                 crate::mem::forget(val);
             };
 

core/src/lib.rs

@@ -178,6 +178,8 @@
 #![feature(is_ascii_octdigit)]
 #![feature(isqrt)]
 #![feature(maybe_uninit_uninit_array)]
+#![feature(offset_of)]
+#![feature(offset_of_enum)]
 #![feature(ptr_alignment_type)]
 #![feature(ptr_metadata)]
 #![feature(set_ptr_value)]

core/src/option.rs

@@ -780,7 +780,7 @@ impl<T> Option<T> {
         // `None` case it's just padding).
         unsafe {
             slice::from_raw_parts(
-                crate::intrinsics::option_payload_ptr(crate::ptr::from_ref(self)),
+                (self as *const Self).byte_add(core::mem::offset_of!(Self, Some.0)).cast(),
                 usize::from(self.is_some()),
             )
         }
@@ -836,8 +836,7 @@ impl<T> Option<T> {
         // the `None` case it's just padding).
         unsafe {
             slice::from_raw_parts_mut(
-                crate::intrinsics::option_payload_ptr(crate::ptr::from_mut(self).cast_const())
-                    .cast_mut(),
+                (self as *mut Self).byte_add(core::mem::offset_of!(Self, Some.0)).cast(),
                 usize::from(self.is_some()),
             )
         }

core/tests/option.rs

@@ -568,3 +568,11 @@ fn zip_unzip_roundtrip() {
     let a = z.unzip();
     assert_eq!(a, (x, y));
 }
+
+#[test]
+fn as_slice() {
+    assert_eq!(Some(42).as_slice(), &[42]);
+    assert_eq!(Some(43).as_mut_slice(), &[43]);
+    assert_eq!(None::<i32>.as_slice(), &[]);
+    assert_eq!(None::<i32>.as_mut_slice(), &[]);
+}