tokio: Stabilize LocalRuntime

Author: Daksh14

tests-integration/tests/macros_main.rs

@@ -16,7 +16,6 @@ async fn spawning() -> usize {
     join.await.unwrap()
 }
 
-#[cfg(tokio_unstable)]
 #[tokio::main(flavor = "local")]
 async fn local_main() -> usize {
     let join = tokio::task::spawn_local(async { 1 });
@@ -33,6 +32,5 @@ fn shell() {
     assert_eq!(1, basic_main());
     assert_eq!(bool::default(), generic_fun::<bool>());
 
-    #[cfg(tokio_unstable)]
     assert_eq!(1, local_main());
 }

tokio/src/runtime/builder.rs

@@ -1,9 +1,11 @@
 #![cfg_attr(loom, allow(unused_imports))]
 
 use crate::runtime::handle::Handle;
-use crate::runtime::{blocking, driver, Callback, HistogramBuilder, Runtime, TaskCallback};
+use crate::runtime::{
+    blocking, driver, Callback, HistogramBuilder, LocalOptions, LocalRuntime, Runtime, TaskCallback,
+};
 #[cfg(tokio_unstable)]
-use crate::runtime::{metrics::HistogramConfiguration, LocalOptions, LocalRuntime, TaskMeta};
+use crate::runtime::{metrics::HistogramConfiguration, TaskMeta};
 use crate::util::rand::{RngSeed, RngSeedGenerator};
 
 use crate::runtime::blocking::BlockingPool;
@@ -923,7 +925,6 @@ impl Builder {
     /// });
     /// ```
     #[allow(unused_variables, unreachable_patterns)]
-    #[cfg(tokio_unstable)]
     #[cfg_attr(docsrs, doc(cfg(tokio_unstable)))]
     pub fn build_local(&mut self, options: LocalOptions) -> io::Result<LocalRuntime> {
         match &self.kind {
@@ -1438,7 +1439,6 @@ impl Builder {
         ))
     }
 
-    #[cfg(tokio_unstable)]
     fn build_current_thread_local_runtime(&mut self) -> io::Result<LocalRuntime> {
         use crate::runtime::local_runtime::LocalRuntimeScheduler;
 

tokio/src/runtime/handle.rs

@@ -361,14 +361,13 @@ impl Handle {
     {
         let id = crate::runtime::task::Id::next();
         #[cfg(all(
-            tokio_unstable,
             tokio_taskdump,
             feature = "rt",
             target_os = "linux",
             any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
         ))]
         let future = super::task::trace::Trace::root(future);
-        #[cfg(all(tokio_unstable, feature = "tracing"))]
+        #[cfg(feature = "tracing")]
         let future = crate::util::trace::task(future, "task", meta, id.as_u64());
         self.inner.spawn_local(future, id, meta.spawned_at)
     }

tokio/src/runtime/local_runtime/runtime.rs

@@ -29,7 +29,6 @@ use std::time::Duration;
 /// [runtime]: crate::runtime::Runtime
 /// [module]: crate::runtime
 #[derive(Debug)]
-#[cfg_attr(docsrs, doc(cfg(tokio_unstable)))]
 pub struct LocalRuntime {
     /// Task scheduler
     scheduler: LocalRuntimeScheduler,
@@ -231,15 +230,14 @@ impl LocalRuntime {
     #[track_caller]
     fn block_on_inner<F: Future>(&self, future: F, _meta: SpawnMeta<'_>) -> F::Output {
         #[cfg(all(
-            tokio_unstable,
             tokio_taskdump,
             feature = "rt",
             target_os = "linux",
             any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
         ))]
         let future = crate::runtime::task::trace::Trace::root(future);
 
-        #[cfg(all(tokio_unstable, feature = "tracing"))]
+        #[cfg(feature = "tracing")]
         let future = crate::util::trace::task(
             future,
             "block_on",
@@ -320,6 +318,7 @@ impl LocalRuntime {
     /// use std::time::Duration;
     ///
     /// fn main() {
+    /// #  if cfg!(miri) { return } // Miri reports error when main thread terminated without waiting all remaining threads.
     ///    let runtime = LocalRuntime::new().unwrap();
     ///
     ///    runtime.block_on(async move {

tokio/src/runtime/mod.rs

@@ -371,8 +371,6 @@ cfg_rt! {
         pub use self::builder::UnhandledPanic;
         pub use crate::util::rand::RngSeed;
 
-        mod local_runtime;
-        pub use local_runtime::{LocalRuntime, LocalOptions};
     }
 
     cfg_taskdump! {
@@ -394,6 +392,9 @@ cfg_rt! {
     mod runtime;
     pub use runtime::{Runtime, RuntimeFlavor};
 
+    mod local_runtime;
+    pub use local_runtime::{LocalRuntime, LocalOptions};
+
     /// Boundary value to prevent stack overflow caused by a large-sized
     /// Future being placed in the stack.
     pub(crate) const BOX_FUTURE_THRESHOLD: usize = if cfg!(debug_assertions)  {

tokio/src/task/local.rs

@@ -327,7 +327,7 @@ cfg_rt! {
     /// Spawns a `!Send` future on the current [`LocalSet`] or [`LocalRuntime`].
     ///
     /// This is possible when either using one of these types
-    /// explicitly, or (with `tokio_unstable`) by opting to use the
+    /// explicitly by opting to use the
     /// `"local"` runtime flavor in `tokio::main`:
     ///
     /// ```ignore
@@ -407,7 +407,6 @@ cfg_rt! {
                 let future = future.take().unwrap();
 
                 #[cfg(all(
-                    tokio_unstable,
                     tokio_taskdump,
                     feature = "rt",
                     target_os = "linux",

tokio/tests/async_send_sync.rs

@@ -559,6 +559,9 @@ assert_value!(tokio::runtime::EnterGuard<'_>: !Send & Sync & Unpin);
 assert_value!(tokio::runtime::Handle: Send & Sync & Unpin);
 assert_value!(tokio::runtime::Runtime: Send & Sync & Unpin);
 
+assert_value!(tokio::runtime::LocalRuntime: !Send & !Sync & Unpin);
+assert_value!(tokio::runtime::LocalOptions: !Send & !Sync & Unpin);
+
 assert_value!(tokio::time::Interval: Send & Sync & Unpin);
 assert_value!(tokio::time::Instant: Send & Sync & Unpin);
 assert_value!(tokio::time::Sleep: Send & Sync & !Unpin);
@@ -768,11 +771,3 @@ mod unix_asyncfd {
     async_assert_fn!(AsyncFd<ImplsFd<NN>>::writable(_): !Send & !Sync & !Unpin);
     async_assert_fn!(AsyncFd<ImplsFd<NN>>::writable_mut(_): !Send & !Sync & !Unpin);
 }
-
-#[cfg(tokio_unstable)]
-mod unstable {
-    use super::*;
-
-    assert_value!(tokio::runtime::LocalRuntime: !Send & !Sync & Unpin);
-    assert_value!(tokio::runtime::LocalOptions: !Send & !Sync & Unpin);
-}

tokio/tests/rt_local.rs

@@ -1,5 +1,5 @@
 #![warn(rust_2018_idioms)]
-#![cfg(all(feature = "full", tokio_unstable))]
+#![cfg(feature = "full")]
 
 use tokio::runtime::LocalOptions;
 use tokio::task::spawn_local;