task: add track_caller to public APIs

tokio/src/runtime/mod.rs

@@ -475,6 +475,7 @@ cfg_rt! {
         /// ```
         ///
         /// [handle]: fn@Handle::block_on
+        #[track_caller]
         pub fn block_on<F: Future>(&self, future: F) -> F::Output {
             #[cfg(all(tokio_unstable, feature = "tracing"))]
             let future = crate::util::trace::task(future, "block_on", None, task::Id::next().as_u64());

tokio/src/task/local.rs

@@ -487,6 +487,7 @@ impl LocalSet {
     /// [`Runtime::block_on`]: method@crate::runtime::Runtime::block_on
     /// [in-place blocking]: fn@crate::task::block_in_place
     /// [`spawn_blocking`]: fn@crate::task::spawn_blocking
+    #[track_caller]
     #[cfg(feature = "rt")]
     #[cfg_attr(docsrs, doc(cfg(feature = "rt")))]
     pub fn block_on<F>(&self, rt: &crate::runtime::Runtime, future: F) -> F::Output

tokio/src/task/task_local.rs

@@ -287,6 +287,7 @@ impl<T: Copy + 'static> LocalKey<T> {
     /// # Panics
     ///
     /// This function will panic if the task local doesn't have a value set.
+    #[track_caller]
     pub fn get(&'static self) -> T {
         self.with(|v| *v)
     }
@@ -425,6 +426,7 @@ enum ScopeInnerErr {
 }
 
 impl ScopeInnerErr {
+    #[track_caller]
     fn panic(&self) -> ! {
         match self {
             Self::BorrowError => panic!("cannot enter a task-local scope while the task-local storage is borrowed"),

tokio/tests/task_panic.rs

@@ -0,0 +1,92 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))]
+
+use futures::future;
+use std::error::Error;
+use tokio::{runtime::Builder, spawn, task};
+
+mod support {
+    pub mod panic;
+}
+use support::panic::test_panic;
+
+#[test]
+fn local_set_block_on_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let rt = Builder::new_current_thread().enable_all().build().unwrap();
+        let local = task::LocalSet::new();
+
+        rt.block_on(async {
+            local.block_on(&rt, future::pending::<()>());
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn spawn_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        spawn(future::pending::<()>());
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn local_key_sync_scope_panic_caller() -> Result<(), Box<dyn Error>> {
+    tokio::task_local! {
+        static NUMBER: u32;
+    }
+
+    let panic_location_file = test_panic(|| {
+        NUMBER.sync_scope(1, || {
+            NUMBER.with(|_| {
+                let _ = NUMBER.sync_scope(1, || {});
+            });
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn local_key_with_panic_caller() -> Result<(), Box<dyn Error>> {
+    tokio::task_local! {
+        static NUMBER: u32;
+    }
+
+    let panic_location_file = test_panic(|| {
+        NUMBER.with(|_| {});
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn local_key_get_panic_caller() -> Result<(), Box<dyn Error>> {
+    tokio::task_local! {
+        static NUMBER: u32;
+    }
+
+    let panic_location_file = test_panic(|| {
+        NUMBER.get();
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}