Auto merge of #51532 - MajorBreakfast:task-future, r=cramertj

Improve core::task::TaskObj

- Rename `UnsafePoll` to `UnsafeTask` to avoid confusion with `Poll`
- Rename `TaskObj::from_poll_task()` to `TaskObj::new()`
- Rename `TaskObj`'s `poll` and `drop` fields to `poll_fn` and `drop_fn`
- Implement `Future` for `TaskObj`. Reason: It's a custom trait object for a future, so it should implement future
- Remove `unsafe impl Sync` for `TaskObj`. I don't think we need it. Was this safe? `UnsafeTask` only requires to implement `Send`

@cramertj
@aturon

Author: bors

src/liballoc/boxed.rs

@@ -66,7 +66,7 @@ use core::marker::{Unpin, Unsize};
 use core::mem::{self, PinMut};
 use core::ops::{CoerceUnsized, Deref, DerefMut, Generator, GeneratorState};
 use core::ptr::{self, NonNull, Unique};
-use core::task::{Context, Poll, UnsafePoll, TaskObj};
+use core::task::{Context, Poll, UnsafeTask, TaskObj};
 use core::convert::From;
 
 use raw_vec::RawVec;
@@ -933,7 +933,7 @@ impl<'a, F: ?Sized + Future> Future for PinBox<F> {
 }
 
 #[unstable(feature = "futures_api", issue = "50547")]
-unsafe impl<F: Future<Output = ()> + Send + 'static> UnsafePoll for PinBox<F> {
+unsafe impl<F: Future<Output = ()> + Send + 'static> UnsafeTask for PinBox<F> {
     fn into_raw(self) -> *mut () {
         PinBox::into_raw(self) as *mut ()
     }
@@ -952,13 +952,13 @@ unsafe impl<F: Future<Output = ()> + Send + 'static> UnsafePoll for PinBox<F> {
 #[unstable(feature = "futures_api", issue = "50547")]
 impl<F: Future<Output = ()> + Send + 'static> From<PinBox<F>> for TaskObj {
     fn from(boxed: PinBox<F>) -> Self {
-        TaskObj::from_poll_task(boxed)
+        TaskObj::new(boxed)
     }
 }
 
 #[unstable(feature = "futures_api", issue = "50547")]
 impl<F: Future<Output = ()> + Send + 'static> From<Box<F>> for TaskObj {
     fn from(boxed: Box<F>) -> Self {
-        TaskObj::from_poll_task(PinBox::from(boxed))
+        TaskObj::new(PinBox::from(boxed))
     }
 }

src/libcore/task.rs

@@ -16,6 +16,8 @@
 
 use fmt;
 use ptr::NonNull;
+use future::Future;
+use mem::PinMut;
 
 /// Indicates whether a value is available or if the current task has been
 /// scheduled to receive a wakeup instead.
@@ -455,8 +457,8 @@ pub trait Executor {
 /// `Box<Future<Output = ()> + Send>`.
 pub struct TaskObj {
     ptr: *mut (),
-    poll: unsafe fn(*mut (), &mut Context) -> Poll<()>,
-    drop: unsafe fn(*mut ()),
+    poll_fn: unsafe fn(*mut (), &mut Context) -> Poll<()>,
+    drop_fn: unsafe fn(*mut ()),
 }
 
 impl fmt::Debug for TaskObj {
@@ -467,7 +469,6 @@ impl fmt::Debug for TaskObj {
 }
 
 unsafe impl Send for TaskObj {}
-unsafe impl Sync for TaskObj {}
 
 /// A custom implementation of a task trait object for `TaskObj`, providing
 /// a hand-rolled vtable.
@@ -478,7 +479,7 @@ unsafe impl Sync for TaskObj {}
 /// The implementor must guarantee that it is safe to call `poll` repeatedly (in
 /// a non-concurrent fashion) with the result of `into_raw` until `drop` is
 /// called.
-pub unsafe trait UnsafePoll: Send + 'static {
+pub unsafe trait UnsafeTask: Send + 'static {
     /// Convert a owned instance into a (conceptually owned) void pointer.
     fn into_raw(self) -> *mut ();
 
@@ -504,30 +505,30 @@ pub unsafe trait UnsafePoll: Send + 'static {
 impl TaskObj {
     /// Create a `TaskObj` from a custom trait object representation.
     #[inline]
-    pub fn from_poll_task<T: UnsafePoll>(t: T) -> TaskObj {
+    pub fn new<T: UnsafeTask>(t: T) -> TaskObj {
         TaskObj {
             ptr: t.into_raw(),
-            poll: T::poll,
-            drop: T::drop,
+            poll_fn: T::poll,
+            drop_fn: T::drop,
         }
     }
+}
+
+impl Future for TaskObj {
+    type Output = ();
 
-    /// Poll the task.
-    ///
-    /// The semantics here are identical to that for futures, but unlike
-    /// futures only an `&mut self` reference is needed here.
     #[inline]
-    pub fn poll_task(&mut self, cx: &mut Context) -> Poll<()> {
+    fn poll(self: PinMut<Self>, cx: &mut Context) -> Poll<()> {
         unsafe {
-            (self.poll)(self.ptr, cx)
+            (self.poll_fn)(self.ptr, cx)
         }
     }
 }
 
 impl Drop for TaskObj {
     fn drop(&mut self) {
         unsafe {
-            (self.drop)(self.ptr)
+            (self.drop_fn)(self.ptr)
         }
     }
 }