chore: switch to std::task::Wake

`tokio::util::Wake` was a copy of `std::task::Wake`, which is now stable for our MSRV.

Author: vilgotf

tokio/src/runtime/scheduler/current_thread/mod.rs

@@ -10,14 +10,14 @@ use crate::runtime::{
 };
 use crate::sync::notify::Notify;
 use crate::util::atomic_cell::AtomicCell;
-use crate::util::{waker_ref, RngSeedGenerator, Wake, WakerRef};
+use crate::util::{waker_ref, RngSeedGenerator, WakerRef};
 
 use std::cell::RefCell;
 use std::collections::VecDeque;
 use std::future::{poll_fn, Future};
 use std::sync::atomic::Ordering::{AcqRel, Release};
 use std::task::Poll::{Pending, Ready};
-use std::task::Waker;
+use std::task::{Wake, Waker};
 use std::thread::ThreadId;
 use std::time::Duration;
 use std::{fmt, thread};
@@ -694,14 +694,14 @@ impl Schedule for Arc<Handle> {
 }
 
 impl Wake for Handle {
-    fn wake(arc_self: Arc<Self>) {
-        Wake::wake_by_ref(&arc_self);
+    fn wake(self: Arc<Self>) {
+        self.wake_by_ref();
     }
 
     /// Wake by reference
-    fn wake_by_ref(arc_self: &Arc<Self>) {
-        arc_self.shared.woken.store(true, Release);
-        arc_self.driver.unpark();
+    fn wake_by_ref(self: &Arc<Self>) {
+        self.shared.woken.store(true, Release);
+        self.driver.unpark();
     }
 }
 

tokio/src/util/idle_notified_set.rs

@@ -9,12 +9,12 @@
 use std::marker::PhantomPinned;
 use std::mem::ManuallyDrop;
 use std::ptr::NonNull;
-use std::task::{Context, Waker};
+use std::task::{Context, Wake, Waker};
 
 use crate::loom::cell::UnsafeCell;
 use crate::loom::sync::{Arc, Mutex};
 use crate::util::linked_list::{self, Link};
-use crate::util::{waker_ref, Wake};
+use crate::util::waker_ref;
 
 type LinkedList<T> =
     linked_list::LinkedList<ListEntry<T>, <ListEntry<T> as linked_list::Link>::Target>;
@@ -432,12 +432,16 @@ impl<T> Drop for IdleNotifiedSet<T> {
 }
 
 impl<T: 'static> Wake for ListEntry<T> {
-    fn wake_by_ref(me: &Arc<Self>) {
-        let mut lock = me.parent.lock();
+    fn wake(self: Arc<Self>) {
+        self.wake_by_ref();
+    }
+
+    fn wake_by_ref(self: &Arc<Self>) {
+        let mut lock = self.parent.lock();
 
         // Safety: We are holding the lock and we will update the lists to
         // maintain invariants.
-        let old_my_list = me.my_list.with_mut(|ptr| unsafe {
+        let old_my_list = self.my_list.with_mut(|ptr| unsafe {
             let old_my_list = *ptr;
             if old_my_list == List::Idle {
                 *ptr = List::Notified;
@@ -449,7 +453,7 @@ impl<T: 'static> Wake for ListEntry<T> {
             // We move ourself to the notified list.
             let me = unsafe {
                 // Safety: We just checked that we are in this particular list.
-                lock.idle.remove(ListEntry::as_raw(me)).unwrap()
+                lock.idle.remove(ListEntry::as_raw(self)).unwrap()
             };
             lock.notified.push_front(me);
 
@@ -459,10 +463,6 @@ impl<T: 'static> Wake for ListEntry<T> {
             }
         }
     }
-
-    fn wake(me: Arc<Self>) {
-        Self::wake_by_ref(&me);
-    }
 }
 
 /// # Safety

tokio/src/util/mod.rs

@@ -68,7 +68,7 @@ cfg_rt! {
 
     mod wake;
     pub(crate) use wake::WakerRef;
-    pub(crate) use wake::{waker_ref, Wake};
+    pub(crate) use wake::waker_ref;
 
     mod sync_wrapper;
     pub(crate) use sync_wrapper::SyncWrapper;

tokio/src/util/wake.rs

@@ -3,16 +3,7 @@ use crate::loom::sync::Arc;
 use std::marker::PhantomData;
 use std::mem::ManuallyDrop;
 use std::ops::Deref;
-use std::task::{RawWaker, RawWakerVTable, Waker};
-
-/// Simplified waking interface based on Arcs.
-pub(crate) trait Wake: Send + Sync + Sized + 'static {
-    /// Wake by value.
-    fn wake(arc_self: Arc<Self>);
-
-    /// Wake by reference.
-    fn wake_by_ref(arc_self: &Arc<Self>);
-}
+use std::task::{RawWaker, RawWakerVTable, Wake, Waker};
 
 /// A `Waker` that is only valid for a given lifetime.
 #[derive(Debug)]