add stability annotations

p-avital · p-avital · commit ffa028dfe53a · 2023-03-30T16:50:44.000+02:00
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
@@ -150,6 +150,7 @@
 #![feature(slice_ptr_get)]
 #![feature(slice_ptr_len)]
 #![feature(slice_range)]
+#![feature(stable_wakers)]
 #![feature(str_internals)]
 #![feature(strict_provenance)]
 #![feature(trusted_len)]
diff --git a/library/alloc/src/task.rs b/library/alloc/src/task.rs
@@ -121,33 +121,45 @@ impl<W: Wake + Send + Sync + 'static> From<Arc<W>> for RawWaker {
 #[inline(always)]
 fn raw_waker<W: Wake + Send + Sync + 'static>(waker: Arc<W>) -> RawWaker {
     // Increment the reference count of the arc to clone it.
-    unsafe fn clone_waker<W: Wake + Send + Sync + 'static>(waker: *const ()) -> RawWaker {
+    unsafe extern "C" fn clone_waker<W: Wake + Send + Sync + 'static>(
+        waker: *const (),
+    ) -> RawWaker {
         unsafe { Arc::increment_strong_count(waker as *const W) };
         RawWaker::new(
             waker as *const (),
-            &RawWakerVTable::new(clone_waker::<W>, wake::<W>, wake_by_ref::<W>, drop_waker::<W>),
+            &RawWakerVTable::new_with_c_abi(
+                clone_waker::<W>,
+                wake::<W>,
+                wake_by_ref::<W>,
+                drop_waker::<W>,
+            ),
         )
     }
 
     // Wake by value, moving the Arc into the Wake::wake function
-    unsafe fn wake<W: Wake + Send + Sync + 'static>(waker: *const ()) {
+    unsafe extern "C" fn wake<W: Wake + Send + Sync + 'static>(waker: *const ()) {
         let waker = unsafe { Arc::from_raw(waker as *const W) };
         <W as Wake>::wake(waker);
     }
 
     // Wake by reference, wrap the waker in ManuallyDrop to avoid dropping it
-    unsafe fn wake_by_ref<W: Wake + Send + Sync + 'static>(waker: *const ()) {
+    unsafe extern "C" fn wake_by_ref<W: Wake + Send + Sync + 'static>(waker: *const ()) {
         let waker = unsafe { ManuallyDrop::new(Arc::from_raw(waker as *const W)) };
         <W as Wake>::wake_by_ref(&waker);
     }
 
     // Decrement the reference count of the Arc on drop
-    unsafe fn drop_waker<W: Wake + Send + Sync + 'static>(waker: *const ()) {
+    unsafe extern "C" fn drop_waker<W: Wake + Send + Sync + 'static>(waker: *const ()) {
         unsafe { Arc::decrement_strong_count(waker as *const W) };
     }
 
     RawWaker::new(
         Arc::into_raw(waker) as *const (),
-        &RawWakerVTable::new(clone_waker::<W>, wake::<W>, wake_by_ref::<W>, drop_waker::<W>),
+        &RawWakerVTable::new_with_c_abi(
+            clone_waker::<W>,
+            wake::<W>,
+            wake_by_ref::<W>,
+            drop_waker::<W>,
+        ),
     )
 }
diff --git a/library/core/src/task/wake.rs b/library/core/src/task/wake.rs
@@ -63,23 +63,6 @@ impl RawWaker {
 }
 
 const RAW_WAKER_VTABLE_V1_PADDING: usize = 0;
-
-/// A virtual function pointer table (vtable) that specifies the behavior
-/// of a [`RawWaker`].
-///
-/// The pointer passed to all functions inside the vtable is the `data` pointer
-/// from the enclosing [`RawWaker`] object.
-///
-/// The functions inside this struct are only intended to be called on the `data`
-/// pointer of a properly constructed [`RawWaker`] object from inside the
-/// [`RawWaker`] implementation. Calling one of the contained functions using
-/// any other `data` pointer will cause undefined behavior.
-///
-/// These functions must all be thread-safe (even though [`RawWaker`] is
-/// <code>\![Send] + \![Sync]</code>)
-/// because [`Waker`] is <code>[Send] + [Sync]</code>, and thus wakers may be moved to
-/// arbitrary threads or invoked by `&` reference. For example, this means that if the
-/// `clone` and `drop` functions manage a reference count, they must do so atomically.
 #[stable(feature = "futures_api", since = "1.36.0")]
 #[derive(PartialEq, Copy, Clone, Debug)]
 #[repr(C)]
@@ -159,18 +142,42 @@ struct RawWakerVTableV2 {
     padding: [*const (); 2 + RAW_WAKER_VTABLE_V1_PADDING], // Reserved space for future changes to the v-table, the need for it and amount are debatable.
 }
 
+/// A virtual function pointer table (vtable) that specifies the behavior
+/// of a [`RawWaker`].
+///
+/// The pointer passed to all functions inside the vtable is the `data` pointer
+/// from the enclosing [`RawWaker`] object.
+///
+/// The functions inside this struct are only intended to be called on the `data`
+/// pointer of a properly constructed [`RawWaker`] object from inside the
+/// [`RawWaker`] implementation. Calling one of the contained functions using
+/// any other `data` pointer will cause undefined behavior.
+///
+/// These functions must all be thread-safe (even though [`RawWaker`] is
+/// <code>\![Send] + \![Sync]</code>)
+/// because [`Waker`] is <code>[Send] + [Sync]</code>, and thus wakers may be moved to
+/// arbitrary threads or invoked by `&` reference. For example, this means that if the
+/// `clone` and `drop` functions manage a reference count, they must do so atomically.
 #[repr(C)]
 #[derive(Clone, Copy)]
+#[stable(feature = "futures_api", since = "1.36.0")]
 pub union RawWakerVTable {
     v1: RawWakerVTableV1,
     v2: RawWakerVTableV2,
 }
+#[stable(feature = "futures_api", since = "1.36.0")]
+unsafe impl Send for RawWakerVTable {}
+#[stable(feature = "futures_api", since = "1.36.0")]
+unsafe impl Sync for RawWakerVTable {}
 
+#[stable(feature = "futures_api", since = "1.36.0")]
 impl PartialEq for RawWakerVTable {
     fn eq(&self, other: &Self) -> bool {
         unsafe { self.v2 == other.v2 }
     }
 }
+
+#[stable(feature = "futures_api", since = "1.36.0")]
 impl fmt::Debug for RawWakerVTable {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         unsafe {
@@ -182,6 +189,21 @@ impl fmt::Debug for RawWakerVTable {
     }
 }
 
+#[allow(improper_ctypes_definitions)]
+/// # Safety
+/// This function must only be called with function pointers sourced from the same shared object
+unsafe extern "C" fn clone_adapter(
+    clone: unsafe fn(*const ()) -> RawWaker,
+    data: *const (),
+) -> RawWaker {
+    unsafe { (clone)(data) }
+}
+#[allow(improper_ctypes_definitions)]
+/// # Safety
+/// This function must only be called with function pointers sourced from the same shared object
+unsafe extern "C" fn other_adapter(other: unsafe fn(*const ()), data: *const ()) {
+    unsafe { (other)(data) }
+}
 impl RawWakerVTable {
     /// Creates a new `RawWakerVTable` from the provided `clone`, `wake`,
     /// `wake_by_ref`, and `drop` functions.
@@ -192,7 +214,7 @@ impl RawWakerVTable {
     /// arbitrary threads or invoked by `&` reference. For example, this means that if the
     /// `clone` and `drop` functions manage a reference count, they must do so atomically.
     ///
-    /# `clone`
+    /// # `clone`
     ///
     /// This function will be called when the [`RawWaker`] gets cloned, e.g. when
     /// the [`Waker`] in which the [`RawWaker`] is stored gets cloned.
@@ -202,7 +224,7 @@ impl RawWakerVTable {
     /// task. Calling `wake` on the resulting [`RawWaker`] should result in a wakeup
     /// of the same task that would have been awoken by the original [`RawWaker`].
     ///
-    /# `wake`
+    /// # `wake`
     ///
     /// This function will be called when `wake` is called on the [`Waker`].
     /// It must wake up the task associated with this [`RawWaker`].
@@ -211,15 +233,15 @@ impl RawWakerVTable {
     /// resources that are associated with this instance of a [`RawWaker`] and
     /// associated task.
     ///
-    /# `wake_by_ref`
+    /// # `wake_by_ref`
     ///
     /// This function will be called when `wake_by_ref` is called on the [`Waker`].
     /// It must wake up the task associated with this [`RawWaker`].
     ///
     /// This function is similar to `wake`, but must not consume the provided data
     /// pointer.
     ///
-    /# `drop`
+    /// # `drop`
     ///
     /// This function gets called when a [`Waker`] gets dropped.
     ///
@@ -229,22 +251,17 @@ impl RawWakerVTable {
     #[rustc_promotable]
     #[stable(feature = "futures_api", since = "1.36.0")]
     #[rustc_const_stable(feature = "futures_api", since = "1.36.0")]
-    #[deprecated = "This constructor makes slower wakers, use new_with_c_abi instead"]
+    #[deprecated(
+        since = "TBD",
+        note = "This constructor makes slower wakers",
+        suggestion = "new_with_c_abi"
+    )]
     pub const fn new(
         clone: unsafe fn(*const ()) -> RawWaker,
         wake: unsafe fn(*const ()),
         wake_by_ref: unsafe fn(*const ()),
         drop: unsafe fn(*const ()),
     ) -> Self {
-        unsafe extern "C" fn clone_adapter(
-            clone: unsafe fn(*const ()) -> RawWaker,
-            data: *const (),
-        ) -> RawWaker {
-            clone(data)
-        }
-        unsafe extern "C" fn other_adapter(other: unsafe fn(*const ()), data: *const ()) {
-            other(data)
-        }
         Self {
             v1: RawWakerVTableV1 {
                 clone,
@@ -267,7 +284,7 @@ impl RawWakerVTable {
     /// arbitrary threads or invoked by `&` reference. For example, this means that if the
     /// `clone` and `drop` functions manage a reference count, they must do so atomically.
     ///
-    /# `clone`
+    /// # `clone`
     ///
     /// This function will be called when the [`RawWaker`] gets cloned, e.g. when
     /// the [`Waker`] in which the [`RawWaker`] is stored gets cloned.
@@ -277,7 +294,7 @@ impl RawWakerVTable {
     /// task. Calling `wake` on the resulting [`RawWaker`] should result in a wakeup
     /// of the same task that would have been awoken by the original [`RawWaker`].
     ///
-    /# `wake`
+    /// # `wake`
     ///
     /// This function will be called when `wake` is called on the [`Waker`].
     /// It must wake up the task associated with this [`RawWaker`].
@@ -286,22 +303,24 @@ impl RawWakerVTable {
     /// resources that are associated with this instance of a [`RawWaker`] and
     /// associated task.
     ///
-    /# `wake_by_ref`
+    /// # `wake_by_ref`
     ///
     /// This function will be called when `wake_by_ref` is called on the [`Waker`].
     /// It must wake up the task associated with this [`RawWaker`].
     ///
     /// This function is similar to `wake`, but must not consume the provided data
     /// pointer.
     ///
-    /# `drop`
+    /// # `drop`
     ///
     /// This function gets called when a [`Waker`] gets dropped.
     ///
     /// The implementation of this function must make sure to release any
     /// resources that are associated with this instance of a [`RawWaker`] and
     /// associated task.
     #[rustc_promotable]
+    #[unstable(feature = "stable_wakers", issue = "109706")]
+    #[rustc_const_unstable(feature = "stable_wakers", issue = "109706")]
     pub const fn new_with_c_abi(
         clone: unsafe extern "C" fn(*const ()) -> RawWaker,
         wake: unsafe extern "C" fn(*const ()),
@@ -345,11 +364,7 @@ impl<'a> Context<'a> {
     #[must_use]
     #[inline]
     pub const fn from_waker(waker: &'a Waker) -> Self {
-        Context {
-            waker,
-            _marker: PhantomData,
-            _marker2: PhantomData,
-        }
+        Context { waker, _marker: PhantomData, _marker2: PhantomData }
     }
 
     /// Returns a reference to the [`Waker`] for the current task.
@@ -365,9 +380,7 @@ impl<'a> Context<'a> {
 #[stable(feature = "futures_api", since = "1.36.0")]
 impl fmt::Debug for Context<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Context")
-            .field("waker", &self.waker)
-            .finish()
+        f.debug_struct("Context").field("waker", &self.waker).finish()
     }
 }
 
@@ -437,16 +450,9 @@ impl Waker {
         unsafe {
             match *vtable {
                 RawWakerVTable {
-                    v1:
-                        RawWakerVTableV1 {
-                            wake,
-                            other_adapter: Some(other_adapter),
-                            ..
-                        },
+                    v1: RawWakerVTableV1 { wake, other_adapter: Some(other_adapter), .. },
                 } => (other_adapter)(wake, data),
-                RawWakerVTable {
-                    v2: RawWakerVTableV2 { wake, .. },
-                } => (wake)(data),
+                RawWakerVTable { v2: RawWakerVTableV2 { wake, .. } } => (wake)(data),
             }
         };
     }
@@ -467,16 +473,9 @@ impl Waker {
         unsafe {
             match *vtable {
                 RawWakerVTable {
-                    v1:
-                        RawWakerVTableV1 {
-                            wake_by_ref,
-                            other_adapter: Some(other_adapter),
-                            ..
-                        },
+                    v1: RawWakerVTableV1 { wake_by_ref, other_adapter: Some(other_adapter), .. },
                 } => (other_adapter)(wake_by_ref, data),
-                RawWakerVTable {
-                    v2: RawWakerVTableV2 { wake_by_ref, .. },
-                } => (wake_by_ref)(data),
+                RawWakerVTable { v2: RawWakerVTableV2 { wake_by_ref, .. } } => (wake_by_ref)(data),
             }
         }
     }
@@ -529,16 +528,9 @@ impl Clone for Waker {
             waker: unsafe {
                 match *vtable {
                     RawWakerVTable {
-                        v1:
-                            RawWakerVTableV1 {
-                                clone,
-                                clone_adapter: Some(clone_adapter),
-                                ..
-                            },
+                        v1: RawWakerVTableV1 { clone, clone_adapter: Some(clone_adapter), .. },
                     } => (clone_adapter)(clone, data),
-                    RawWakerVTable {
-                        v2: RawWakerVTableV2 { clone, .. },
-                    } => (clone)(data),
+                    RawWakerVTable { v2: RawWakerVTableV2 { clone, .. } } => (clone)(data),
                 }
             },
         }
@@ -556,16 +548,9 @@ impl Drop for Waker {
         unsafe {
             match *vtable {
                 RawWakerVTable {
-                    v1:
-                        RawWakerVTableV1 {
-                            drop,
-                            other_adapter: Some(other_adapter),
-                            ..
-                        },
+                    v1: RawWakerVTableV1 { drop, other_adapter: Some(other_adapter), .. },
                 } => (other_adapter)(drop, data),
-                RawWakerVTable {
-                    v2: RawWakerVTableV2 { drop, .. },
-                } => (drop)(data),
+                RawWakerVTable { v2: RawWakerVTableV2 { drop, .. } } => (drop)(data),
             }
         }
     }
