cleanup feature flags, add abort module

Signed-off-by: Eliza Weisman <[email protected]>

tokio/src/runtime/task/abort.rs

@@ -0,0 +1,69 @@
+use crate::runtime::task::RawTask;
+use std::fmt;
+use std::panic::{RefUnwindSafe, UnwindSafe};
+
+/// An owned permission to abort a spawned task, without awaiting its completion.
+///
+/// Unlike a [`JoinHandle`], an `AbortHandle` does *not* represent the
+/// permission to await the task's completion, only to terminate it.
+///
+/// The task may be aborted by calling the [`AbortHandle::abort`] method.
+/// Dropping an `AbortHandle` releases the permission to terminate the task
+/// --- it does *not* abort the task.
+///
+/// **Note**: This is an [unstable API][unstable]. The public API of this type
+/// may break in 1.x releases. See [the documentation on unstable
+/// features][unstable] for details.
+///
+/// [unstable]: crate#unstable-features
+/// [`JoinHandle`]: crate::task::JoinHandle
+#[cfg_attr(docsrs, doc(cfg(all(feature = "rt", tokio_unstable))))]
+#[cfg_attr(not(tokio_unstable), allow(unreachable_pub))]
+pub struct AbortHandle {
+    raw: Option<RawTask>,
+}
+
+impl AbortHandle {
+    pub(super) fn new(raw: Option<RawTask>) -> Self {
+        Self { raw }
+    }
+
+    /// Abort the task associated with the handle.
+    ///
+    /// Awaiting a cancelled task might complete as usual if the task was
+    /// already completed at the time it was cancelled, but most likely it
+    /// will fail with a [cancelled] `JoinError`.
+    ///
+    /// If the task was already cancelled, such as by [`JoinHandle::abort`],
+    /// this method will do nothing.
+    ///
+    /// [cancelled]: method@super::error::JoinError::is_cancelled
+    // the `AbortHandle` type is only publicly exposed when `tokio_unstable` is
+    // enabled, but it is still defined for testing purposes.
+    #[cfg_attr(not(tokio_unstable), allow(unreachable_pub))]
+    pub fn abort(self) {
+        if let Some(raw) = self.raw {
+            raw.remote_abort();
+        }
+    }
+}
+
+unsafe impl Send for AbortHandle {}
+unsafe impl Sync for AbortHandle {}
+
+impl UnwindSafe for AbortHandle {}
+impl RefUnwindSafe for AbortHandle {}
+
+impl fmt::Debug for AbortHandle {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt.debug_struct("AbortHandle").finish()
+    }
+}
+
+impl Drop for AbortHandle {
+    fn drop(&mut self) {
+        if let Some(raw) = self.raw.take() {
+            raw.drop_abort_handle();
+        }
+    }
+}

tokio/src/runtime/task/join.rs

@@ -146,27 +146,6 @@ cfg_rt! {
         raw: Option<RawTask>,
         _p: PhantomData<T>,
     }
-
-    /// An owned permission to abort a spawned task, without awaiting its completion.
-    ///
-    /// Unlike a [`JoinHandle`], an `AbortHandle` does *not* represent the
-    /// permission to await the task's completion, only to terminate it.
-    ///
-    /// The task may be aborted by calling the [`AbortHandle::abort`] method.
-    /// Dropping an `AbortHandle` releases the permission to terminate the task
-    /// --- it does *not* abort the task.
-    ///
-    /// **Note**: This is an [unstable API][unstable]. The public API of this type
-    /// may break in 1.x releases. See [the documentation on unstable
-    /// features][unstable] for details.
-    ///
-    /// [unstable]: crate#unstable-features
-    #[cfg(any(tokio_unstable, test))]
-    #[cfg_attr(docsrs, doc(cfg(tokio_unstable)))]
-    pub struct AbortHandle {
-        raw: Option<RawTask>,
-    }
-
 }
 
 unsafe impl<T: Send> Send for JoinHandle<T> {}
@@ -233,12 +212,13 @@ impl<T> JoinHandle<T> {
     }
 
     /// Returns a new `AbortHandle` that can be used to remotely abort this task.
-    pub(crate) fn abort_handle(&self) -> AbortHandle {
+    #[cfg(any(tokio_unstable, test))]
+    pub(crate) fn abort_handle(&self) -> super::AbortHandle {
         let raw = self.raw.map(|raw| {
             raw.ref_inc();
             raw
         });
-        AbortHandle { raw }
+        super::AbortHandle::new(raw)
     }
 }
 
@@ -303,44 +283,3 @@ where
         fmt.debug_struct("JoinHandle").finish()
     }
 }
-
-impl AbortHandle {
-    /// Abort the task associated with the handle.
-    ///
-    /// Awaiting a cancelled task might complete as usual if the task was
-    /// already completed at the time it was cancelled, but most likely it
-    /// will fail with a [cancelled] `JoinError`.
-    ///
-    /// If the task was already cancelled, such as by [`JoinHandle::abort`],
-    /// this method will do nothing.
-    ///
-    /// [cancelled]: method@super::error::JoinError::is_cancelled
-    // the `AbortHandle` type is only publicly exposed when `tokio_unstable` is
-    // enabled, but it is still defined for testing purposes.
-    #[cfg_attr(not(tokio_unstable), allow(unreachable_pub))]
-    pub fn abort(self) {
-        if let Some(raw) = self.raw {
-            raw.remote_abort();
-        }
-    }
-}
-
-unsafe impl Send for AbortHandle {}
-unsafe impl Sync for AbortHandle {}
-
-impl UnwindSafe for AbortHandle {}
-impl RefUnwindSafe for AbortHandle {}
-
-impl fmt::Debug for AbortHandle {
-    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt.debug_struct("AbortHandle").finish()
-    }
-}
-
-impl Drop for AbortHandle {
-    fn drop(&mut self) {
-        if let Some(raw) = self.raw.take() {
-            raw.drop_abort_handle();
-        }
-    }
-}

tokio/src/runtime/task/mod.rs

@@ -155,15 +155,13 @@ cfg_rt_multi_thread! {
     pub(super) use self::inject::Inject;
 }
 
+#[cfg(all(feature = "rt", any(tokio_unstable, test)))]
+mod abort;
 mod join;
 
-cfg_unstable! {
-    #[allow(unreachable_pub)] // https://github.com/rust-lang/rust/issues/57411
-    pub use self::join::AbortHandle;
-}
-#[cfg(all(not(tokio_unstable), test))]
-#[allow(unused_imports)]
-pub(crate) use self::join::AbortHandle;
+#[cfg(all(feature = "rt", any(tokio_unstable, test)))]
+#[allow(unreachable_pub)] // https://github.com/rust-lang/rust/issues/57411
+pub use self::abort::AbortHandle;
 
 #[allow(unreachable_pub)] // https://github.com/rust-lang/rust/issues/57411
 pub use self::join::JoinHandle;