1 files changed, 50 insertions, 22 deletions

diff --git a/tokio/src/time/driver/handle.rs b/tokio/src/time/driver/handle.rs
index e9e53e56..93d8cd7b 100644
--- a/tokio/src/time/driver/handle.rs
+++ b/tokio/src/time/driver/handle.rs
@@ -1,4 +1,3 @@
-use crate::runtime::context;
 use crate::time::driver::Inner;
 use std::fmt;
 use std::sync::{Arc, Weak};
@@ -15,33 +14,62 @@ impl Handle {
         Handle { inner }
     }
 
-    /// Tries to get a handle to the current timer.
-    ///
-    /// # Panics
-    ///
-    /// This function panics if there is no current timer set.
-    ///
-    /// It can be triggered when `Builder::enable_time()` or
-    /// `Builder::enable_all()` are not included in the builder.
-    ///
-    /// It can also panic whenever a timer is created outside of a Tokio
-    /// runtime. That is why `rt.block_on(sleep(...))` will panic,
-    /// since the function is executed outside of the runtime.
-    /// Whereas `rt.block_on(async {sleep(...).await})` doesn't
-    /// panic. And this is because wrapping the function on an async makes it
-    /// lazy, and so gets executed inside the runtime successfuly without
-    /// panicking.
-    pub(crate) fn current() -> Self {
-        context::time_handle()
-            .expect("there is no timer running, must be called from the context of Tokio runtime")
-    }
-
     /// Tries to return a strong ref to the inner
     pub(crate) fn inner(&self) -> Option<Arc<Inner>> {
         self.inner.upgrade()
     }
 }
 
+cfg_rt_core! {
+    impl Handle {
+        /// Tries to get a handle to the current timer.
+        ///
+        /// # Panics
+        ///
+        /// This function panics if there is no current timer set.
+        ///
+        /// It can be triggered when `Builder::enable_time()` or
+        /// `Builder::enable_all()` are not included in the builder.
+        ///
+        /// It can also panic whenever a timer is created outside of a Tokio
+        /// runtime. That is why `rt.block_on(delay_for(...))` will panic,
+        /// since the function is executed outside of the runtime.
+        /// Whereas `rt.block_on(async {delay_for(...).await})` doesn't
+        /// panic. And this is because wrapping the function on an async makes it
+        /// lazy, and so gets executed inside the runtime successfuly without
+        /// panicking.
+        pub(crate) fn current() -> Self {
+            crate::runtime::context::time_handle()
+                .expect("there is no timer running, must be called from the context of Tokio runtime")
+        }
+    }
+}
+
+cfg_not_rt_core! {
+    impl Handle {
+        /// Tries to get a handle to the current timer.
+        ///
+        /// # Panics
+        ///
+        /// This function panics if there is no current timer set.
+        ///
+        /// It can be triggered when `Builder::enable_time()` or
+        /// `Builder::enable_all()` are not included in the builder.
+        ///
+        /// It can also panic whenever a timer is created outside of a Tokio
+        /// runtime. That is why `rt.block_on(delay_for(...))` will panic,
+        /// since the function is executed outside of the runtime.
+        /// Whereas `rt.block_on(async {delay_for(...).await})` doesn't
+        /// panic. And this is because wrapping the function on an async makes it
+        /// lazy, and so gets executed inside the runtime successfuly without
+        /// panicking.
+        pub(crate) fn current() -> Self {
+            panic!("there is no timer running, must be called from the context of Tokio runtime or \
+            `rt-core` is not enabled")
+        }
+    }
+}
+
 impl fmt::Debug for Handle {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Handle")