rt: split internal runtime::Handle concerns (#5022)

The `runtime::Handle` struct is part of the public API but is also used
internally. This has created a bit of tension. An earlier patch made
defined Handle as a private struct in some cases when `rt` is not
enabled.

This patch splits out internal handle concerns into a new
`scheduler::Handle` type, which will only be internal. This also defines
a `Handle` type for each scheduler variant. Eventually, the
per-scheduler `Handle` types will replace the per-scheduler `Spawner`
types, but more work is needed before we can make that change.

tokio/src/runtime/blocking/pool.rs

@@ -154,7 +154,7 @@ cfg_fs! {
         R: Send + 'static,
     {
         let rt = context::current();
-        rt.as_inner().blocking_spawner.spawn_mandatory_blocking(&rt, func)
+        rt.inner.blocking_spawner().spawn_mandatory_blocking(&rt, func)
     }
 }
 
@@ -419,7 +419,7 @@ impl Spawner {
         builder.spawn(move || {
             // Only the reference should be moved into the closure
             let _enter = crate::runtime::context::enter(rt.clone());
-            rt.as_inner().blocking_spawner.inner.run(id);
+            rt.inner.blocking_spawner().inner.run(id);
             drop(shutdown_tx);
         })
     }

tokio/src/runtime/builder.rs

@@ -1,5 +1,5 @@
 use crate::runtime::handle::Handle;
-use crate::runtime::{blocking, driver, Callback, Runtime, Spawner};
+use crate::runtime::{blocking, driver, Callback, Runtime};
 use crate::util::{RngSeed, RngSeedGenerator};
 
 use std::fmt;
@@ -874,7 +874,8 @@ impl Builder {
     }
 
     fn build_current_thread_runtime(&mut self) -> io::Result<Runtime> {
-        use crate::runtime::{Config, CurrentThread, HandleInner, Scheduler};
+        use crate::runtime::scheduler::{self, current_thread, CurrentThread};
+        use crate::runtime::{Config, Scheduler};
         use std::sync::Arc;
 
         let (driver, driver_handle) = driver::Driver::new(self.get_cfg())?;
@@ -900,14 +901,13 @@ impl Builder {
                 seed_generator: self.seed_generator.next_generator(),
             },
         );
-        let spawner = Spawner::CurrentThread(scheduler.spawner().clone());
-
-        let inner = Arc::new(HandleInner {
-            spawner,
+        let inner = Arc::new(current_thread::Handle {
+            spawner: scheduler.spawner().clone(),
             driver: driver_handle,
             blocking_spawner,
             seed_generator: self.seed_generator.next_generator(),
         });
+        let inner = scheduler::Handle::CurrentThread(inner);
 
         Ok(Runtime {
             scheduler: Scheduler::CurrentThread(scheduler),
@@ -993,7 +993,8 @@ cfg_rt_multi_thread! {
     impl Builder {
         fn build_threaded_runtime(&mut self) -> io::Result<Runtime> {
             use crate::loom::sys::num_cpus;
-            use crate::runtime::{Config, HandleInner, Scheduler, MultiThread};
+            use crate::runtime::{Config, Scheduler};
+            use crate::runtime::scheduler::{self, multi_thread, MultiThread};
             use std::sync::Arc;
 
             let core_threads = self.worker_threads.unwrap_or_else(num_cpus);
@@ -1019,14 +1020,14 @@ cfg_rt_multi_thread! {
                     seed_generator: self.seed_generator.next_generator(),
                 },
             );
-            let spawner = Spawner::MultiThread(scheduler.spawner().clone());
 
-            let inner = Arc::new(HandleInner {
-                spawner,
+            let inner = Arc::new(multi_thread::Handle {
+                spawner: scheduler.spawner().clone(),
                 driver: driver_handle,
                 blocking_spawner,
                 seed_generator: self.seed_generator.next_generator(),
             });
+            let inner = scheduler::Handle::MultiThread(inner);
 
             // Create the runtime handle
             let handle = Handle { inner };

tokio/src/runtime/context.rs

@@ -31,8 +31,8 @@ cfg_io_driver! {
             let ctx = ctx.borrow();
             ctx.as_ref()
                 .expect(crate::util::error::CONTEXT_MISSING_ERROR)
-                .as_inner()
-                .driver
+                .inner
+                .driver()
                 .io
                 .clone()
         }) {
@@ -49,9 +49,8 @@ cfg_signal_internal! {
             let ctx = ctx.borrow();
             ctx.as_ref()
                 .expect(crate::util::error::CONTEXT_MISSING_ERROR)
-                .as_inner()
-                .driver
-                .signal
+                .inner
+                .signal()
                 .clone()
         }) {
             Ok(signal_handle) => signal_handle,
@@ -65,10 +64,9 @@ cfg_time! {
         pub(crate) fn clock() -> Option<crate::runtime::driver::Clock> {
             match CONTEXT.try_with(|ctx| {
                 let ctx = ctx.borrow();
-                ctx.as_ref()
-                    .map(|ctx| {
-                        ctx.as_inner().driver.clock.clone()
-                     })
+                ctx
+                    .as_ref()
+                    .map(|ctx| ctx.inner.clock().clone())
             }) {
                 Ok(clock) => clock,
                 Err(_) => panic!("{}", crate::util::error::THREAD_LOCAL_DESTROYED_ERROR),
@@ -77,15 +75,6 @@ cfg_time! {
     }
 }
 
-cfg_rt! {
-    pub(crate) fn spawn_handle() -> Option<crate::runtime::Spawner> {
-        match CONTEXT.try_with(|ctx| (*ctx.borrow()).as_ref().map(|ctx| ctx.inner.spawner.clone())) {
-            Ok(spawner) => spawner,
-            Err(_) => panic!("{}", crate::util::error::THREAD_LOCAL_DESTROYED_ERROR),
-        }
-    }
-}
-
 /// Sets this [`Handle`] as the current active [`Handle`].
 ///
 /// [`Handle`]: Handle
@@ -100,7 +89,7 @@ pub(crate) fn enter(new: Handle) -> EnterGuard {
 ///
 /// [`Handle`]: Handle
 pub(crate) fn try_enter(new: Handle) -> Option<EnterGuard> {
-    let rng_seed = new.as_inner().seed_generator.next_seed();
+    let rng_seed = new.inner.seed_generator().next_seed();
     let old_handle = CONTEXT.try_with(|ctx| ctx.borrow_mut().replace(new)).ok()?;
 
     let old_seed = replace_thread_rng(rng_seed);