rt: simplify rt-* features (#2949)

tokio:

    merge rt-core and rt-util as rt
    rename rt-threaded to rt-multi-thread

tokio-util:

    rename rt-core to rt

Closes #2942

35 files changed, 133 insertions, 172 deletions

diff --git a/tokio/Cargo.toml b/tokio/Cargo.toml
index 5b361e6b..6b0c4d8c 100644
--- a/tokio/Cargo.toml
+++ b/tokio/Cargo.toml
@@ -37,9 +37,8 @@ full = [
   "macros",
   "net",
   "process",
-  "rt-core",
-  "rt-util",
-  "rt-threaded",
+  "rt",
+  "rt-multi-thread",
   "signal",
   "stream",
   "sync",
@@ -71,11 +70,10 @@ process = [
   "winapi/threadpoollegacyapiset",
 ]
 # Includes basic task execution capabilities
-rt-core = ["slab"]
-rt-util = []
-rt-threaded = [
+rt = ["slab"]
+rt-multi-thread = [
   "num_cpus",
-  "rt-core",
+  "rt",
 ]
 signal = [
   "lazy_static",
diff --git a/tokio/src/blocking.rs b/tokio/src/blocking.rs
index d6ef5915..f88b1db1 100644
--- a/tokio/src/blocking.rs
+++ b/tokio/src/blocking.rs
@@ -1,9 +1,9 @@
-cfg_rt_core! {
+cfg_rt! {
     pub(crate) use crate::runtime::spawn_blocking;
     pub(crate) use crate::task::JoinHandle;
 }
 
-cfg_not_rt_core! {
+cfg_not_rt! {
     use std::fmt;
     use std::future::Future;
     use std::pin::Pin;
@@ -15,7 +15,7 @@ cfg_not_rt_core! {
         R: Send + 'static,
     {
         assert_send_sync::<JoinHandle<std::cell::Cell<()>>>();
-        panic!("requires the `rt-core` Tokio feature flag")
+        panic!("requires the `rt` Tokio feature flag")
 
     }
 
diff --git a/tokio/src/coop.rs b/tokio/src/coop.rs
index f6cca1c5..980cdf8c 100644
--- a/tokio/src/coop.rs
+++ b/tokio/src/coop.rs
@@ -83,7 +83,7 @@ impl Budget {
     }
 }
 
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     impl Budget {
         fn has_remaining(self) -> bool {
             self.0.map(|budget| budget > 0).unwrap_or(true)
@@ -122,7 +122,7 @@ fn with_budget<R>(budget: Budget, f: impl FnOnce() -> R) -> R {
     })
 }
 
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     /// Set the current task's budget
     pub(crate) fn set(budget: Budget) {
         CURRENT.with(|cell| cell.set(budget))
@@ -134,7 +134,7 @@ cfg_rt_threaded! {
     }
 }
 
-cfg_rt_core! {
+cfg_rt! {
     /// Forcibly remove the budgeting constraints early.
     ///
     /// Returns the remaining budget
diff --git a/tokio/src/future/block_on.rs b/tokio/src/future/block_on.rs
index 9fc7abc6..91f9cc00 100644
--- a/tokio/src/future/block_on.rs
+++ b/tokio/src/future/block_on.rs
@@ -1,13 +1,13 @@
 use std::future::Future;
 
-cfg_rt_core! {
+cfg_rt! {
     pub(crate) fn block_on<F: Future>(f: F) -> F::Output {
         let mut e = crate::runtime::enter::enter(false);
         e.block_on(f).unwrap()
     }
 }
 
-cfg_not_rt_core! {
+cfg_not_rt! {
     pub(crate) fn block_on<F: Future>(f: F) -> F::Output {
         let mut park = crate::park::thread::CachedParkThread::new();
         park.block_on(f).unwrap()
diff --git a/tokio/src/io/driver/mod.rs b/tokio/src/io/driver/mod.rs
index 0d4133a5..cd82b26f 100644
--- a/tokio/src/io/driver/mod.rs
+++ b/tokio/src/io/driver/mod.rs
@@ -1,4 +1,4 @@
-#![cfg_attr(not(feature = "rt-core"), allow(dead_code))]
+#![cfg_attr(not(feature = "rt"), allow(dead_code))]
 
 mod ready;
 use ready::Ready;
@@ -219,13 +219,13 @@ impl fmt::Debug for Driver {
 
 // ===== impl Handle =====
 
-cfg_rt_core! {
+cfg_rt! {
     impl Handle {
         /// Returns a handle to the current reactor
         ///
         /// # Panics
         ///
-        /// This function panics if there is no current reactor set and `rt-core` feature
+        /// This function panics if there is no current reactor set and `rt` feature
         /// flag is not enabled.
         pub(super) fn current() -> Self {
             crate::runtime::context::io_handle()
@@ -234,16 +234,16 @@ cfg_rt_core! {
     }
 }
 
-cfg_not_rt_core! {
+cfg_not_rt! {
     impl Handle {
         /// Returns a handle to the current reactor
         ///
         /// # Panics
         ///
-        /// This function panics if there is no current reactor set, or if the `rt-core`
+        /// This function panics if there is no current reactor set, or if the `rt`
         /// feature flag is not enabled.
         pub(super) fn current() -> Self {
-            panic!("there is no reactor running, must be called from the context of Tokio runtime with `rt-core` enabled.")
+            panic!("there is no reactor running, must be called from the context of Tokio runtime with `rt` enabled.")
         }
     }
 }
diff --git a/tokio/src/lib.rs b/tokio/src/lib.rs
index 92d2c35d..483f13ed 100644
--- a/tokio/src/lib.rs
+++ b/tokio/src/lib.rs
@@ -73,9 +73,9 @@
 //! need.
 //!
 //! - `full`: Enables all Tokio public API features listed below.
-//! - `rt-core`: Enables `tokio::spawn` and the basic (single-threaded) scheduler.
-//! - `rt-threaded`: Enables the heavier, multi-threaded, work-stealing scheduler.
-//! - `rt-util`: Enables non-scheduler utilities.
+//! - `rt-core`: Enables `tokio::spawn`, the basic (current thread) scheduler,
+//! and non-scheduler utilities.
+//! - `rt-multi-thread`: Enables the heavier, multi-threaded, work-stealing scheduler.
 //! - `io-util`: Enables the IO based `Ext` traits.
 //! - `io-std`: Enable `Stdout`, `Stdin` and `Stderr` types.
 //! - `net`: Enables `tokio::net` types such as `TcpStream`, `UnixStream` and `UdpSocket`.
@@ -134,7 +134,7 @@
 //! needs to `tokio::spawn` and use a `TcpStream`.
 //!
 //! ```toml
-//! tokio = { version = "0.2", features = ["rt-core", "net"] }
+//! tokio = { version = "0.2", features = ["rt", "net"] }
 //! ```
 //!
 //! ## Working With Tasks
@@ -148,7 +148,7 @@
 //! * Functions for [running blocking operations][blocking] in an asynchronous
 //!   task context.
 //!
-//! The [`tokio::task`] module is present only when the "rt-core" feature flag
+//! The [`tokio::task`] module is present only when the "rt" feature flag
 //! is enabled.
 //!
 //! [tasks]: task/index.html#what-are-tasks
@@ -196,9 +196,9 @@
 //! and managing runtimes. You should use that module if the `#[tokio::main]` macro doesn't
 //! provide the functionality you need.
 //!
-//! Using the runtime requires the "rt-core" or "rt-threaded" feature flags, to
-//! enable the basic [single-threaded scheduler][rt-core] and the [thread-pool
-//! scheduler][rt-threaded], respectively. See the [`runtime` module
+//! Using the runtime requires the "rt" or "rt-multi-thread" feature flags, to
+//! enable the basic [single-threaded scheduler][rt] and the [thread-pool
+//! scheduler][rt-multi-thread], respectively. See the [`runtime` module
 //! documentation][rt-features] for details. In addition, the "macros" feature
 //! flag enables the `#[tokio::main]` and `#[tokio::test]` attributes.
 //!
@@ -206,8 +206,8 @@
 //! [`tokio::runtime`]: crate::runtime
 //! [`Builder`]: crate::runtime::Builder
 //! [`Runtime`]: crate::runtime::Runtime
-//! [rt-core]: runtime/index.html#basic-scheduler
-//! [rt-threaded]: runtime/index.html#threaded-scheduler
+//! [rt]: runtime/index.html#basic-scheduler
+//! [rt-multi-thread]: runtime/index.html#threaded-scheduler
 //! [rt-features]: runtime/index.html#runtime-scheduler
 //!
 //! ## CPU-bound tasks and blocking code
@@ -362,11 +362,9 @@ cfg_process! {
 #[cfg(any(feature = "dns", feature = "fs", feature = "io-std"))]
 mod blocking;
 
-cfg_rt_core! {
+cfg_rt! {
     pub mod runtime;
 }
-#[cfg(all(not(feature = "rt-core"), feature = "rt-util"))]
-mod runtime;
 
 pub(crate) mod coop;
 
@@ -393,7 +391,7 @@ cfg_not_sync! {
 }
 
 pub mod task;
-cfg_rt_core! {
+cfg_rt! {
     pub use task::spawn;
 }
 
@@ -410,8 +408,8 @@ cfg_macros! {
     #[doc(hidden)]
     pub use tokio_macros::select_priv_declare_output_enum;
 
-    doc_rt_core! {
-        cfg_rt_threaded! {
+    cfg_rt! {
+        cfg_rt_multi_thread! {
             // This is the docs.rs case (with all features) so make sure macros
             // is included in doc(cfg).
 
@@ -423,15 +421,15 @@ cfg_macros! {
             pub use tokio_macros::test;
         }
 
-        cfg_not_rt_threaded! {
+        cfg_not_rt_multi_thread! {
             #[cfg(not(test))] // Work around for rust-lang/rust#62127
-            pub use tokio_macros::main_rt_core as main;
-            pub use tokio_macros::test_rt_core as test;
+            pub use tokio_macros::main_rt as main;
+            pub use tokio_macros::test_rt as test;
         }
     }
 
-    // Always fail if rt-core is not enabled.
-    cfg_not_rt_core! {
+    // Always fail if rt is not enabled.
+    cfg_not_rt! {
         #[cfg(not(test))]
         pub use tokio_macros::main_fail as main;
         pub use tokio_macros::test_fail as test;
diff --git a/tokio/src/loom/std/mod.rs b/tokio/src/loom/std/mod.rs
index fc32fc9f..95252868 100644
--- a/tokio/src/loom/std/mod.rs
+++ b/tokio/src/loom/std/mod.rs
@@ -79,12 +79,12 @@ pub(crate) mod sync {
 }
 
 pub(crate) mod sys {
-    #[cfg(feature = "rt-threaded")]
+    #[cfg(feature = "rt-multi-thread")]
     pub(crate) fn num_cpus() -> usize {
         usize::max(1, num_cpus::get())
     }
 
-    #[cfg(not(feature = "rt-threaded"))]
+    #[cfg(not(feature = "rt-multi-thread"))]
     pub(crate) fn num_cpus() -> usize {
         1
     }
diff --git a/tokio/src/macros/cfg.rs b/tokio/src/macros/cfg.rs
index 849fb42b..fedef7ad 100644
--- a/tokio/src/macros/cfg.rs
+++ b/tokio/src/macros/cfg.rs
@@ -8,7 +8,7 @@ macro_rules! cfg_block_on {
                     feature = "fs",
                     feature = "dns",
                     feature = "io-std",
-                    feature = "rt-core",
+                    feature = "rt",
                     ))]
             $item
         )*
@@ -22,7 +22,7 @@ macro_rules! cfg_atomic_waker_impl {
             #[cfg(any(
                 feature = "net",
                 feature = "process",
-                feature = "rt-util",
+                feature = "rt",
                 feature = "signal",
                 feature = "time",
             ))]
@@ -251,64 +251,35 @@ macro_rules! cfg_not_sync {
     }
 }
 
-macro_rules! cfg_rt_core {
+macro_rules! cfg_rt {
     ($($item:item)*) => {
         $(
-            #[cfg(feature = "rt-core")]
+            #[cfg(feature = "rt")]
+            #[cfg_attr(docsrs, doc(cfg(feature = "rt")))]
             $item
         )*
     }
 }
 
-macro_rules! cfg_task {
+macro_rules! cfg_not_rt {
     ($($item:item)*) => {
-        $(
-            #[cfg(any(feature = "rt-core", feature = "rt-util"))]
-            #[cfg_attr(docsrs, doc(cfg(any(feature = "rt-core", feature = "rt-util"))))]
-            $item
-        )*
-    }
-}
-
-macro_rules! doc_rt_core {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "rt-core")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "rt-core")))]
-            $item
-        )*
-    }
-}
-
-macro_rules! cfg_not_rt_core {
-    ($($item:item)*) => {
-        $( #[cfg(not(feature = "rt-core"))] $item )*
-    }
-}
-
-macro_rules! cfg_rt_threaded {
-    ($($item:item)*) => {
-        $(
-            #[cfg(feature = "rt-threaded")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "rt-threaded")))]
-            $item
-        )*
+        $( #[cfg(not(feature = "rt"))] $item )*
     }
 }
 
-macro_rules! cfg_rt_util {
+macro_rules! cfg_rt_multi_thread {
     ($($item:item)*) => {
         $(
-            #[cfg(feature = "rt-util")]
-            #[cfg_attr(docsrs, doc(cfg(feature = "rt-util")))]
+            #[cfg(feature = "rt-multi-thread")]
+            #[cfg_attr(docsrs, doc(cfg(feature = "rt-multi-thread")))]
             $item
         )*
     }
 }
 
-macro_rules! cfg_not_rt_threaded {
+macro_rules! cfg_not_rt_multi_thread {
     ($($item:item)*) => {
-        $( #[cfg(not(feature = "rt-threaded"))] $item )*
+        $( #[cfg(not(feature = "rt-multi-thread"))] $item )*
     }
 }
 
@@ -372,8 +343,7 @@ macro_rules! cfg_coop {
                     feature = "io-std",
                     feature = "net",
                     feature = "process",
-                    feature = "rt-core",
-                    feature = "rt-util",
+                    feature = "rt",
                     feature = "signal",
                     feature = "sync",
                     feature = "stream",
diff --git a/tokio/src/macros/mod.rs b/tokio/src/macros/mod.rs
index a9d87657..b0af5215 100644
--- a/tokio/src/macros/mod.rs
+++ b/tokio/src/macros/mod.rs
@@ -16,7 +16,7 @@ mod ready;
 mod thread_local;
 
 #[macro_use]
-#[cfg(any(feature = "rt-core", feature = "rt-util"))]
+#[cfg(feature = "rt")]
 pub(crate) mod scoped_tls;
 
 cfg_macros! {
diff --git a/tokio/src/park/mod.rs b/tokio/src/park/mod.rs
index e4b97512..5db26ce7 100644
--- a/tokio/src/park/mod.rs
+++ b/tokio/src/park/mod.rs
@@ -34,11 +34,11 @@
 //! * `park_timeout` does the same as `park` but allows specifying a maximum
 //!   time to block the thread for.
 
-cfg_rt_core! {
+cfg_rt! {
     pub(crate) mod either;
 }
 
-#[cfg(any(feature = "rt-core", feature = "rt-util", feature = "sync"))]
+#[cfg(any(feature = "rt", feature = "sync"))]
 pub(crate) mod thread;
 
 use std::sync::Arc;
diff --git a/tokio/src/process/unix/driver.rs b/tokio/src/process/unix/driver.rs
index 62fe8095..9a16cad5 100644
--- a/tokio/src/process/unix/driver.rs
+++ b/tokio/src/process/unix/driver.rs
@@ -1,4 +1,4 @@
-#![cfg_attr(not(feature = "rt-core"), allow(dead_code))]
+#![cfg_attr(not(feature = "rt"), allow(dead_code))]
 
 //! Process driver
 
diff --git a/tokio/src/runtime/builder.rs b/tokio/src/runtime/builder.rs
index 27981d33..735e9b6a 100644
--- a/tokio/src/runtime/builder.rs
+++ b/tokio/src/runtime/builder.rs
@@ -73,7 +73,7 @@ pub(crate) type ThreadNameFn = std::sync::Arc<dyn Fn() -> String + Send + Sync +
 
 pub(crate) enum Kind {
     CurrentThread,
-    #[cfg(feature = "rt-threaded")]
+    #[cfg(feature = "rt-multi-thread")]
     MultiThread,
 }
 
@@ -84,7 +84,7 @@ impl Builder {
     }
 
     /// TODO
-    #[cfg(feature = "rt-threaded")]
+    #[cfg(feature = "rt-multi-thread")]
     pub fn new_multi_thread() -> Builder {
         Builder::new(Kind::MultiThread)
     }
@@ -365,7 +365,7 @@ impl Builder {
     pub fn build(&mut self) -> io::Result<Runtime> {
         match &self.kind {
             Kind::CurrentThread => self.build_basic_runtime(),
-            #[cfg(feature = "rt-threaded")]
+            #[cfg(feature = "rt-multi-thread")]
             Kind::MultiThread => self.build_threaded_runtime(),
         }
     }
@@ -477,7 +477,7 @@ cfg_time! {
     }
 }
 
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     impl Builder {
         fn build_threaded_runtime(&mut self) -> io::Result<Runtime> {
             use crate::loom::sys::num_cpus;
diff --git a/tokio/src/runtime/context.rs b/tokio/src/runtime/context.rs
index e28d5282..9dfca8d8 100644
--- a/tokio/src/runtime/context.rs
+++ b/tokio/src/runtime/context.rs
@@ -48,7 +48,7 @@ cfg_time! {
     }
 }
 
-cfg_rt_core! {
+cfg_rt! {
     pub(crate) fn spawn_handle() -> Option<crate::runtime::Spawner> {
         CONTEXT.with(|ctx| match *ctx.borrow() {
             Some(ref ctx) => Some(ctx.spawner.clone()),
diff --git a/tokio/src/runtime/enter.rs b/tokio/src/runtime/enter.rs
index 79ed4d17..4dd8dd01 100644
--- a/tokio/src/runtime/enter.rs
+++ b/tokio/src/runtime/enter.rs
@@ -4,7 +4,7 @@ use std::marker::PhantomData;
 
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum EnterContext {
-    #[cfg_attr(not(feature = "rt-core"), allow(dead_code))]
+    #[cfg_attr(not(feature = "rt"), allow(dead_code))]
     Entered {
         allow_blocking: bool,
     },
@@ -24,7 +24,7 @@ pub(crate) struct Enter {
     _p: PhantomData<RefCell<()>>,
 }
 
-cfg_rt_core! {
+cfg_rt! {
     use crate::park::thread::ParkError;
 
     use std::time::Duration;
@@ -65,7 +65,7 @@ cfg_rt_core! {
 //
 // This is hidden for a reason. Do not use without fully understanding
 // executors. Misuing can easily cause your program to deadlock.
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     pub(crate) fn exit<F: FnOnce() -> R, R>(f: F) -> R {
         // Reset in case the closure panics
         struct Reset(EnterContext);
@@ -91,7 +91,7 @@ cfg_rt_threaded! {
     }
 }
 
-cfg_rt_util! {
+cfg_rt! {
     /// Disallow blocking in the current runtime context until the guard is dropped.
     pub(crate) fn disallow_blocking() -> DisallowBlockingGuard {
         let reset = ENTERED.with(|c| {
@@ -130,14 +130,14 @@ cfg_rt_util! {
     }
 }
 
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     /// Returns true if in a runtime context.
     pub(crate) fn context() -> EnterContext {
         ENTERED.with(|c| c.get())
     }
 }
 
-cfg_rt_core! {
+cfg_rt! {
     impl Enter {
         /// Blocks the thread on the specified future, returning the value with
         /// which that future completes.
diff --git a/tokio/src/runtime/mod.rs b/tokio/src/runtime/mod.rs
index c79a942f..7712a7f8 100644
--- a/tokio/src/runtime/mod.rs
+++ b/tokio/src/runtime/mod.rs
@@ -114,7 +114,7 @@
 //!
 //! The current-thread scheduler provides a _single-threaded_ future executor.
 //! All tasks will be created and executed on the current thread. This requires
-//! the `rt-core` feature flag.
+//! the `rt` feature flag.
 //! ```
 //! use tokio::runtime;
 //!
@@ -129,7 +129,7 @@
 //! The multi-thread scheduler executes futures on a _thread pool_, using a
 //! work-stealing strategy. By default, it will start a worker thread for each
 //! CPU core available on the system. This tends to be the ideal configurations
-//! for most applications. The multi-thread scheduler requires the `rt-threaded`
+//! for most applications. The multi-thread scheduler requires the `rt-multi-thread`
 //! feature flag, and is selected by default:
 //! ```
 //! use tokio::runtime;
@@ -181,7 +181,7 @@ pub(crate) mod enter;
 
 pub(crate) mod task;
 
-cfg_rt_core! {
+cfg_rt! {
     mod basic_scheduler;
     use basic_scheduler::BasicScheduler;
 
@@ -204,19 +204,19 @@ cfg_rt_core! {
     use self::spawner::Spawner;
 }
 
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     mod park;
     use park::Parker;
 }
 
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     mod queue;
 
     pub(crate) mod thread_pool;
     use self::thread_pool::ThreadPool;
 }
 
-cfg_rt_core! {
+cfg_rt! {
     use crate::task::JoinHandle;
 
     use std::future::Future;
@@ -266,11 +266,11 @@ cfg_rt_core! {
     #[derive(Debug)]
     enum Kind {
         /// Execute all tasks on the current-thread.
-        #[cfg(feature = "rt-core")]
+        #[cfg(feature = "rt")]
         CurrentThread(BasicScheduler<driver::Driver>),
 
         /// Execute tasks across multiple threads.
-        #[cfg(feature = "rt-threaded")]
+        #[cfg(feature = "rt-multi-thread")]
         ThreadPool(ThreadPool),
     }
 
@@ -282,8 +282,8 @@ cfg_rt_core! {
         ///
         /// This results in a scheduler, I/O driver, and time driver being
         /// initialized. The type of scheduler used depends on what feature flags
-        /// are enabled: if the `rt-threaded` feature is enabled, the [threaded
-        /// scheduler] is used, while if only the `rt-core` feature is enabled, the
+        /// are enabled: if the `rt-multi-thread` feature is enabled, the [threaded
+        /// scheduler] is used, while if only the `rt` feature is enabled, the
         /// [basic scheduler] is used instead.
         ///
         /// If the threaded scheduler is selected, it will not spawn
@@ -313,7 +313,7 @@ cfg_rt_core! {
         /// [threaded scheduler]: index.html#threaded-scheduler
         /// [basic scheduler]: index.html#basic-scheduler
         /// [runtime builder]: crate::runtime::Builder
-        #[cfg(feature = "rt-threaded")]
+        #[cfg(feature = "rt-multi-thread")]
         pub fn new() -> std::io::Result<Runtime> {
             Builder::new_multi_thread().enable_all().build()
         }
@@ -343,14 +343,14 @@ cfg_rt_core! {
         /// });
         /// # }
         /// ```
-        #[cfg(feature = "rt-core")]
+        #[cfg(feature = "rt")]
         pub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
         where
             F: Future + Send + 'static,
             F::Output: Send + 'static,
         {
             match &self.kind {
-                #[cfg(feature = "rt-threaded")]
+                #[cfg(feature = "rt-multi-thread")]
                 Kind::ThreadPool(exec) => exec.spawn(future),
                 Kind::CurrentThread(exec) => exec.spawn(future),
             }
@@ -393,9 +393,9 @@ cfg_rt_core! {
         /// [handle]: fn@Handle::block_on
         pub fn block_on<F: Future>(&self, future: F) -> F::Output {
             self.handle.enter(|| match &self.kind {
-                #[cfg(feature = "rt-core")]
+                #[cfg(feature = "rt")]
                 Kind::CurrentThread(exec) => exec.block_on(future),
-                #[cfg(feature = "rt-threaded")]
+                #[cfg(feature = "rt-multi-thread")]
                 Kind::ThreadPool(exec) => exec.block_on(future),
             })
         }
diff --git a/tokio/src/runtime/spawner.rs b/tokio/src/runtime/spawner.rs
index 28ff7c04..a37c6679 100644
--- a/tokio/src/runtime/spawner.rs
+++ b/tokio/src/runtime/spawner.rs
@@ -1,25 +1,25 @@
-cfg_rt_core! {
+cfg_rt! {
     use crate::runtime::basic_scheduler;
     use crate::task::JoinHandle;
 
     use std::future::Future;
 }
 
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     use crate::runtime::thread_pool;
 }
 
 #[derive(Debug, Clone)]
 pub(crate) enum Spawner {
-    #[cfg(feature = "rt-core")]
+    #[cfg(feature = "rt")]
     Basic(basic_scheduler::Spawner),
-    #[cfg(feature = "rt-threaded")]
+    #[cfg(feature = "rt-multi-thread")]
     ThreadPool(thread_pool::Spawner),
 }
 
 impl Spawner {
     pub(crate) fn shutdown(&mut self) {
-        #[cfg(feature = "rt-threaded")]
+        #[cfg(feature = "rt-multi-thread")]
         {
             if let Spawner::ThreadPool(spawner) = self {
                 spawner.shutdown();
@@ -28,7 +28,7 @@ impl Spawner {
     }
 }
 
-cfg_rt_core! {
+cfg_rt! {
     impl Spawner {
         pub(crate) fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
         where
@@ -36,9 +36,9 @@ cfg_rt_core! {
             F::Output: Send + 'static,
         {
             match self {
-                #[cfg(feature = "rt-core")]
+                #[cfg(feature = "rt")]
                 Spawner::Basic(spawner) => spawner.spawn(future),
-                #[cfg(feature = "rt-threaded")]
+                #[cfg(feature = "rt-multi-thread")]
                 Spawner::ThreadPool(spawner) => spawner.spawn(future),
             }
         }
diff --git a/tokio/src/runtime/task/core.rs b/tokio/src/runtime/task/core.rs
index f4756c23..dfa87641 100644
--- a/tokio/src/runtime/task/core.rs
+++ b/tokio/src/runtime/task/core.rs
@@ -269,7 +269,7 @@ impl<T: Future, S: Schedule> Core<T, S> {
     }
 }
 
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     impl Header {
         pub(crate) fn shutdown(&self) {
             use crate::runtime::task::RawTask;
diff --git a/tokio/src/runtime/task/error.rs b/tokio/src/runtime/task/error.rs
index 4197ba60..177fe65e 100644
--- a/tokio/src/runtime/task/error.rs
+++ b/tokio/src/runtime/task/error.rs
@@ -3,7 +3,7 @@ use std::fmt;
 use std::io;
 use std::sync::Mutex;
 
-cfg_task! {
+cfg_rt! {
     /// Task failed to execute to completion.
     pub struct JoinError {
         repr: Repr,
diff --git a/tokio/src/runtime/task/join.rs b/tokio/src/runtime/task/join.rs
index a63f5740..dedfb387 100644
--- a/tokio/src/runtime/task/join.rs
+++ b/tokio/src/runtime/task/join.rs
@@ -6,7 +6,7 @@ use std::marker::PhantomData;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-cfg_task! {
+cfg_rt! {
     /// An owned permission to join on a task (await its termination).
     ///
     /// This can be thought of as the equivalent of [`std::thread::JoinHandle`] for
diff --git a/tokio/src/runtime/task/mod.rs b/tokio/src/runtime/task/mod.rs
index d30a467f..7b49e95a 100644
--- a/tokio/src/runtime/task/mod.rs
+++ b/tokio/src/runtime/task/mod.rs
@@ -21,7 +21,7 @@ use self::state::State;
 
 mod waker;
 
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     mod stack;
     pub(crate) use self::stack::TransferStack;
 }
@@ -79,7 +79,7 @@ pub(crate) trait Schedule: Sync + Sized + 'static {
     }
 }
 
-cfg_rt_core! {
+cfg_rt! {
     /// Create a new task with an associated join handle
     pub(crate) fn joinable<T, S>(task: T) -> (Notified<S>, JoinHandle<T::Output>)
     where
@@ -99,7 +99,7 @@ cfg_rt_core! {
     }
 }
 
-cfg_rt_util! {
+cfg_rt! {
     /// Create a new `!Send` task with an associated join handle
     pub(crate) unsafe fn joinable_local<T, S>(task: T) -> (Notified<S>, JoinHandle<T::Output>)
     where
@@ -132,7 +132,7 @@ impl<S: 'static> Task<S> {
     }
 }
 
-cfg_rt_threaded! {
+cfg_rt_multi_thread! {
     impl<S: 'static> Notified<S> {
         pub(crate) unsafe fn from_raw(ptr: NonNull<Header>) -> Notified<S> {
             Notified(Task::from_raw(ptr))
diff --git a/tokio/src/signal/unix/driver.rs b/tokio/src/signal/unix/driver.rs
index d4a49783..8e5ed7d0 100644
--- a/<