Merge branch 'main' into rp2040-rtc-alarm

18 files changed, 566 insertions, 10 deletions

diff --git a/embassy-executor/tests/test.rs b/embassy-executor/tests/test.rs
index 78c49c071..6baf3dc21 100644
--- a/embassy-executor/tests/test.rs
+++ b/embassy-executor/tests/test.rs
@@ -1,12 +1,13 @@
 #![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+#![cfg_attr(feature = "nightly", feature(never_type))]
 
 use std::boxed::Box;
-use std::future::poll_fn;
+use std::future::{poll_fn, Future};
 use std::sync::{Arc, Mutex};
 use std::task::Poll;
 
 use embassy_executor::raw::Executor;
-use embassy_executor::task;
+use embassy_executor::{task, Spawner};
 
 #[export_name = "__pender"]
 fn __pender(context: *mut ()) {
@@ -58,8 +59,41 @@ fn executor_task() {
         trace.push("poll task1")
     }
 
+    #[task]
+    async fn task2() -> ! {
+        panic!()
+    }
+
     let (executor, trace) = setup();
-    executor.spawner().spawn(task1(trace.clone())).unwrap();
+    executor.spawner().spawn(task1(trace.clone()).unwrap());
+
+    unsafe { executor.poll() };
+    unsafe { executor.poll() };
+
+    assert_eq!(
+        trace.get(),
+        &[
+            "pend",       // spawning a task pends the executor
+            "poll task1", // poll only once.
+        ]
+    )
+}
+
+#[test]
+fn executor_task_rpit() {
+    #[task]
+    fn task1(trace: Trace) -> impl Future<Output = ()> {
+        async move { trace.push("poll task1") }
+    }
+
+    #[cfg(feature = "nightly")]
+    #[task]
+    fn task2() -> impl Future<Output = !> {
+        async { panic!() }
+    }
+
+    let (executor, trace) = setup();
+    executor.spawner().spawn(task1(trace.clone()).unwrap());
 
     unsafe { executor.poll() };
     unsafe { executor.poll() };
@@ -86,7 +120,7 @@ fn executor_task_self_wake() {
     }
 
     let (executor, trace) = setup();
-    executor.spawner().spawn(task1(trace.clone())).unwrap();
+    executor.spawner().spawn(task1(trace.clone()).unwrap());
 
     unsafe { executor.poll() };
     unsafe { executor.poll() };
@@ -118,7 +152,7 @@ fn executor_task_self_wake_twice() {
     }
 
     let (executor, trace) = setup();
-    executor.spawner().spawn(task1(trace.clone())).unwrap();
+    executor.spawner().spawn(task1(trace.clone()).unwrap());
 
     unsafe { executor.poll() };
     unsafe { executor.poll() };
@@ -154,7 +188,7 @@ fn waking_after_completion_does_not_poll() {
     let waker = Box::leak(Box::new(AtomicWaker::new()));
 
     let (executor, trace) = setup();
-    executor.spawner().spawn(task1(trace.clone(), waker)).unwrap();
+    executor.spawner().spawn(task1(trace.clone(), waker).unwrap());
 
     unsafe { executor.poll() };
     waker.wake();
@@ -166,7 +200,7 @@ fn waking_after_completion_does_not_poll() {
     unsafe { executor.poll() }; // Clears running status
 
     // Can respawn waken-but-dead task
-    executor.spawner().spawn(task1(trace.clone(), waker)).unwrap();
+    executor.spawner().spawn(task1(trace.clone(), waker).unwrap());
 
     unsafe { executor.poll() };
 
@@ -216,7 +250,7 @@ fn waking_with_old_waker_after_respawn() {
     let waker = Box::leak(Box::new(AtomicWaker::new()));
 
     let (executor, trace) = setup();
-    executor.spawner().spawn(task1(trace.clone(), waker)).unwrap();
+    executor.spawner().spawn(task1(trace.clone(), waker).unwrap());
 
     unsafe { executor.poll() };
     unsafe { executor.poll() }; // progress to registering the waker
@@ -239,8 +273,7 @@ fn waking_with_old_waker_after_respawn() {
     let (other_executor, other_trace) = setup();
     other_executor
         .spawner()
-        .spawn(task1(other_trace.clone(), waker))
-        .unwrap();
+        .spawn(task1(other_trace.clone(), waker).unwrap());
 
     unsafe { other_executor.poll() }; // just run to the yield_now
     waker.wake(); // trigger old waker registration
@@ -283,3 +316,43 @@ fn executor_task_cfg_args() {
         let (_, _, _) = (a, b, c);
     }
 }
+
+#[test]
+fn recursive_task() {
+    #[embassy_executor::task(pool_size = 2)]
+    async fn task1() {
+        let spawner = unsafe { Spawner::for_current_executor().await };
+        spawner.spawn(task1().unwrap());
+    }
+}
+
+#[cfg(feature = "metadata-name")]
+#[test]
+fn task_metadata() {
+    #[task]
+    async fn task1(expected_name: Option<&'static str>) {
+        use embassy_executor::Metadata;
+        assert_eq!(Metadata::for_current_task().await.name(), expected_name);
+    }
+
+    // check no task name
+    let (executor, _) = setup();
+    executor.spawner().spawn(task1(None).unwrap());
+    unsafe { executor.poll() };
+
+    // check setting task name
+    let token = task1(Some("foo")).unwrap();
+    token.metadata().set_name("foo");
+    executor.spawner().spawn(token);
+    unsafe { executor.poll() };
+
+    let token = task1(Some("bar")).unwrap();
+    token.metadata().set_name("bar");
+    executor.spawner().spawn(token);
+    unsafe { executor.poll() };
+
+    // check name is cleared if the task pool slot is recycled.
+    let (executor, _) = setup();
+    executor.spawner().spawn(task1(None).unwrap());
+    unsafe { executor.poll() };
+}
diff --git a/embassy-executor/tests/ui.rs b/embassy-executor/tests/ui.rs
index 278a4b903..5486a0624 100644
--- a/embassy-executor/tests/ui.rs
+++ b/embassy-executor/tests/ui.rs
@@ -17,8 +17,22 @@ fn ui() {
     t.compile_fail("tests/ui/nonstatic_struct_elided.rs");
     t.compile_fail("tests/ui/nonstatic_struct_generic.rs");
     t.compile_fail("tests/ui/not_async.rs");
+    t.compile_fail("tests/ui/spawn_nonsend.rs");
+    t.compile_fail("tests/ui/return_impl_future_nonsend.rs");
+    if rustversion::cfg!(stable) {
+        // output is slightly different on nightly
+        t.compile_fail("tests/ui/bad_return_impl_future.rs");
+        t.compile_fail("tests/ui/return_impl_send.rs");
+    }
+    if cfg!(feature = "nightly") {
+        t.compile_fail("tests/ui/bad_return_impl_future_nightly.rs");
+        t.compile_fail("tests/ui/return_impl_send_nightly.rs");
+    }
     t.compile_fail("tests/ui/self_ref.rs");
     t.compile_fail("tests/ui/self.rs");
     t.compile_fail("tests/ui/type_error.rs");
     t.compile_fail("tests/ui/where_clause.rs");
+    t.compile_fail("tests/ui/unsafe_op_in_unsafe_task.rs");
+
+    t.pass("tests/ui/task_safety_attribute.rs");
 }
diff --git a/embassy-executor/tests/ui/bad_return_impl_future.rs b/embassy-executor/tests/ui/bad_return_impl_future.rs
new file mode 100644
index 000000000..baaa7dc5a
--- /dev/null
+++ b/embassy-executor/tests/ui/bad_return_impl_future.rs
@@ -0,0 +1,9 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+use core::future::Future;
+
+#[embassy_executor::task]
+fn task() -> impl Future<Output = u32> {
+    async { 5 }
+}
+
+fn main() {}
diff --git a/embassy-executor/tests/ui/bad_return_impl_future.stderr b/embassy-executor/tests/ui/bad_return_impl_future.stderr
new file mode 100644
index 000000000..57f147714
--- /dev/null
+++ b/embassy-executor/tests/ui/bad_return_impl_future.stderr
@@ -0,0 +1,120 @@
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/bad_return_impl_future.rs:5:4
+  |
+4 | #[embassy_executor::task]
+  | ------------------------- required by a bound introduced by this call
+5 | fn task() -> impl Future<Output = u32> {
+  |    ^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Future<Output = u32> {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_size`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_size<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> usize
+  |                  -------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |                         ^^^^^^^^^ required by this bound in `task_pool_size`
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/bad_return_impl_future.rs:4:1
+  |
+4 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Future<Output = u32> {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_size`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_size<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> usize
+  |                  -------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |            ^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `task_pool_size`
+  = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/bad_return_impl_future.rs:5:4
+  |
+4 | #[embassy_executor::task]
+  | ------------------------- required by a bound introduced by this call
+5 | fn task() -> impl Future<Output = u32> {
+  |    ^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Future<Output = u32> {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_align`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_align<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> usize
+  |                  --------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |                         ^^^^^^^^^ required by this bound in `task_pool_align`
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/bad_return_impl_future.rs:4:1
+  |
+4 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Future<Output = u32> {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_align`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_align<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> usize
+  |                  --------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |            ^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `task_pool_align`
+  = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/bad_return_impl_future.rs:5:4
+  |
+4 | #[embassy_executor::task]
+  | ------------------------- required by a bound introduced by this call
+5 | fn task() -> impl Future<Output = u32> {
+  |    ^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Future<Output = u32> {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `__task_pool_get`
+ --> tests/ui/bad_return_impl_future.rs:4:1
+  |
+4 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `__task_pool_get`
+  = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/bad_return_impl_future.rs:5:4
+  |
+4 | #[embassy_executor::task]
+  | ------------------------- required by a bound introduced by this call
+5 | fn task() -> impl Future<Output = u32> {
+  |    ^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Future<Output = u32> {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_new`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_new<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> TaskPool<Fut, POOL_SIZE>
+  |                  ------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |                         ^^^^^^^^^ required by this bound in `task_pool_new`
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/bad_return_impl_future.rs:4:1
+  |
+4 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Future<Output = u32> {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_new`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_new<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> TaskPool<Fut, POOL_SIZE>
+  |                  ------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |            ^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `task_pool_new`
+  = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/embassy-executor/tests/ui/bad_return_impl_future_nightly.rs b/embassy-executor/tests/ui/bad_return_impl_future_nightly.rs
new file mode 100644
index 000000000..baaa7dc5a
--- /dev/null
+++ b/embassy-executor/tests/ui/bad_return_impl_future_nightly.rs
@@ -0,0 +1,9 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+use core::future::Future;
+
+#[embassy_executor::task]
+fn task() -> impl Future<Output = u32> {
+    async { 5 }
+}
+
+fn main() {}
diff --git a/embassy-executor/tests/ui/bad_return_impl_future_nightly.stderr b/embassy-executor/tests/ui/bad_return_impl_future_nightly.stderr
new file mode 100644
index 000000000..3c3c9503b
--- /dev/null
+++ b/embassy-executor/tests/ui/bad_return_impl_future_nightly.stderr
@@ -0,0 +1,10 @@
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/bad_return_impl_future_nightly.rs:4:1
+  |
+4 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `TaskReturnValue` is not implemented for `u32`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+  = help: the following other types implement trait `TaskReturnValue`:
+            ()
+            <fn() -> ! as HasOutput>::Output
diff --git a/embassy-executor/tests/ui/nonstatic_struct_elided.stderr b/embassy-executor/tests/ui/nonstatic_struct_elided.stderr
index 099ef8b4e..0ee1bfe0c 100644
--- a/embassy-executor/tests/ui/nonstatic_struct_elided.stderr
+++ b/embassy-executor/tests/ui/nonstatic_struct_elided.stderr
@@ -8,3 +8,17 @@ help: indicate the anonymous lifetime
   |
 6 | async fn task(_x: Foo<'_>) {}
   |                      ++++
+
+error[E0700]: hidden type for `impl Sized` captures lifetime that does not appear in bounds
+ --> tests/ui/nonstatic_struct_elided.rs:5:1
+  |
+5 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ opaque type defined here
+6 | async fn task(_x: Foo) {}
+  |                   --- hidden type `impl Sized` captures the anonymous lifetime defined here
+  |
+  = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: add a `use<...>` bound to explicitly capture `'_`
+  |
+5 | #[embassy_executor::task] + use<'_>
+  |                           +++++++++
diff --git a/embassy-executor/tests/ui/return_impl_future_nonsend.rs b/embassy-executor/tests/ui/return_impl_future_nonsend.rs
new file mode 100644
index 000000000..77b3119d6
--- /dev/null
+++ b/embassy-executor/tests/ui/return_impl_future_nonsend.rs
@@ -0,0 +1,21 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+use core::future::Future;
+
+use embassy_executor::SendSpawner;
+
+#[embassy_executor::task]
+fn task() -> impl Future<Output = ()> {
+    // runs in spawning thread
+    let non_send: *mut () = core::ptr::null_mut();
+    async move {
+        // runs in executor thread
+        println!("{}", non_send as usize);
+    }
+}
+
+fn send_spawn(s: SendSpawner) {
+    s.spawn(task().unwrap());
+}
+
+fn main() {}
diff --git a/embassy-executor/tests/ui/return_impl_future_nonsend.stderr b/embassy-executor/tests/ui/return_impl_future_nonsend.stderr
new file mode 100644
index 000000000..51944ad65
--- /dev/null
+++ b/embassy-executor/tests/ui/return_impl_future_nonsend.stderr
@@ -0,0 +1,17 @@
+error: future cannot be sent between threads safely
+  --> tests/ui/return_impl_future_nonsend.rs:18:13
+   |
+18 |     s.spawn(task().unwrap());
+   |             ^^^^^^^^^^^^^^^ future created by async block is not `Send`
+   |
+   = help: within `impl Sized`, the trait `Send` is not implemented for `*mut ()`
+note: captured value is not `Send`
+  --> tests/ui/return_impl_future_nonsend.rs:13:24
+   |
+13 |         println!("{}", non_send as usize);
+   |                        ^^^^^^^^ has type `*mut ()` which is not `Send`
+note: required by a bound in `SendSpawner::spawn`
+  --> src/spawner.rs
+   |
+   |     pub fn spawn<S: Send>(&self, token: SpawnToken<S>) {
+   |                     ^^^^ required by this bound in `SendSpawner::spawn`
diff --git a/embassy-executor/tests/ui/return_impl_send.rs b/embassy-executor/tests/ui/return_impl_send.rs
new file mode 100644
index 000000000..6ddb0e722
--- /dev/null
+++ b/embassy-executor/tests/ui/return_impl_send.rs
@@ -0,0 +1,6 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+#[embassy_executor::task]
+fn task() -> impl Send {}
+
+fn main() {}
diff --git a/embassy-executor/tests/ui/return_impl_send.stderr b/embassy-executor/tests/ui/return_impl_send.stderr
new file mode 100644
index 000000000..5d19465ec
--- /dev/null
+++ b/embassy-executor/tests/ui/return_impl_send.stderr
@@ -0,0 +1,137 @@
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/return_impl_send.rs:4:4
+  |
+3 | #[embassy_executor::task]
+  | ------------------------- required by a bound introduced by this call
+4 | fn task() -> impl Send {}
+  |    ^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Send {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_size`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_size<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> usize
+  |                  -------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |                         ^^^^^^^^^ required by this bound in `task_pool_size`
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/return_impl_send.rs:3:1
+  |
+3 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Send {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_size`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_size<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> usize
+  |                  -------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |            ^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `task_pool_size`
+  = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/return_impl_send.rs:4:4
+  |
+3 | #[embassy_executor::task]
+  | ------------------------- required by a bound introduced by this call
+4 | fn task() -> impl Send {}
+  |    ^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Send {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_align`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_align<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> usize
+  |                  --------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |                         ^^^^^^^^^ required by this bound in `task_pool_align`
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/return_impl_send.rs:3:1
+  |
+3 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Send {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_align`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_align<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> usize
+  |                  --------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |            ^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `task_pool_align`
+  = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/return_impl_send.rs:4:4
+  |
+3 | #[embassy_executor::task]
+  | ------------------------- required by a bound introduced by this call
+4 | fn task() -> impl Send {}
+  |    ^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Send {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `__task_pool_get`
+ --> tests/ui/return_impl_send.rs:3:1
+  |
+3 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `__task_pool_get`
+  = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: `impl Send` is not a future
+ --> tests/ui/return_impl_send.rs:3:1
+  |
+3 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ `impl Send` is not a future
+  |
+  = help: the trait `Future` is not implemented for `impl Send`
+note: required by a bound in `TaskPool::<F, N>::spawn`
+ --> src/raw/mod.rs
+  |
+  | impl<F: Future + 'static, const N: usize> TaskPool<F, N> {
+  |         ^^^^^^ required by this bound in `TaskPool::<F, N>::spawn`
+...
+  |     pub fn spawn(&'static self, future: impl FnOnce() -> F) -> Result<SpawnToken<impl Sized>, SpawnError> {
+  |            ----- required by a bound in this associated function
+  = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/return_impl_send.rs:4:4
+  |
+3 | #[embassy_executor::task]
+  | ------------------------- required by a bound introduced by this call
+4 | fn task() -> impl Send {}
+  |    ^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Send {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_new`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_new<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> TaskPool<Fut, POOL_SIZE>
+  |                  ------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |                         ^^^^^^^^^ required by this bound in `task_pool_new`
+
+error[E0277]: task futures must resolve to `()` or `!`
+ --> tests/ui/return_impl_send.rs:3:1
+  |
+3 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `TaskFn<_>` is not implemented for fn item `fn() -> impl Send {__task_task}`
+  |
+  = note: use `async fn` or change the return type to `impl Future<Output = ()>`
+note: required by a bound in `task_pool_new`
+ --> src/lib.rs
+  |
+  |     pub const fn task_pool_new<F, Args, Fut, const POOL_SIZE: usize>(_: F) -> TaskPool<Fut, POOL_SIZE>
+  |                  ------------- required by a bound in this function
+  |     where
+  |         F: TaskFn<Args, Fut = Fut>,
+  |            ^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `task_pool_new`
+  = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/embassy-executor/tests/ui/return_impl_send_nightly.rs b/embassy-executor/tests/ui/return_impl_send_nightly.rs
new file mode 100644
index 000000000..6ddb0e722
--- /dev/null
+++ b/embassy-executor/tests/ui/return_impl_send_nightly.rs
@@ -0,0 +1,6 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+#[embassy_executor::task]
+fn task() -> impl Send {}
+
+fn main() {}
diff --git a/embassy-executor/tests/ui/return_impl_send_nightly.stderr b/embassy-executor/tests/ui/return_impl_send_nightly.stderr
new file mode 100644
index 000000000..de9ba6243
--- /dev/null
+++ b/embassy-executor/tests/ui/return_impl_send_nightly.stderr
@@ -0,0 +1,10 @@
+error[E0277]: `impl Send` is not a future
+ --> tests/ui/return_impl_send_nightly.rs:3:1
+  |
+3 | #[embassy_executor::task]
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^
+  | |
+  | `impl Send` is not a future
+  | return type was inferred to be `impl Send` here
+  |
+  = help: the trait `Future` is not implemented for `impl Send`
diff --git a/embassy-executor/tests/ui/spawn_nonsend.rs b/embassy-executor/tests/ui/spawn_nonsend.rs
new file mode 100644
index 000000000..601041941
--- /dev/null
+++ b/embassy-executor/tests/ui/spawn_nonsend.rs
@@ -0,0 +1,16 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+
+use core::future::Future;
+
+use embassy_executor::SendSpawner;
+
+#[embassy_executor::task]
+async fn task(non_send: *mut ()) {
+    println!("{}", non_send as usize);
+}
+
+fn send_spawn(s: SendSpawner) {
+    s.spawn(task(core::ptr::null_mut()).unwrap());
+}
+
+fn main() {}
diff --git a/embassy-executor/tests/ui/spawn_nonsend.stderr b/embassy-executor/tests/ui/spawn_nonsend.stderr
new file mode 100644
index 000000000..25bd7d78d
--- /dev/null
+++ b/embassy-executor/tests/ui/spawn_nonsend.stderr
@@ -0,0 +1,41 @@
+warning: unused import: `core::future::Future`
+ --> tests/ui/spawn_nonsend.rs:3:5
+  |
+3 | use core::future::Future;
+  |     ^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: `#[warn(unused_imports)]` on by default
+
+error[E0277]: `*mut ()` cannot be sent between threads safely
+  --> tests/ui/spawn_nonsend.rs:13:13
+   |
+7  | #[embassy_executor::task]
+   | ------------------------- within this `impl Sized`
+...
+13 |     s.spawn(task(core::ptr::null_mut()).unwrap());
+   |       ----- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `*mut ()` cannot be sent between threads safely
+   |       |
+   |       required by a bound introduced by this call
+   |
+   = help: within `impl Sized`, the trait `Send` is not implemented for `*mut ()`
+note: required because it's used within this closure
+  --> tests/ui/spawn_nonsend.rs:7:1
+   |
+7  | #[embassy_executor::task]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: required because it appears within the type `impl Sized`
+  --> src/raw/mod.rs
+   |
+   |     pub unsafe fn _spawn_async_fn<FutFn>(&'static self, future: FutFn) -> Result<SpawnToken<impl Sized>, SpawnError>
+   |                                                                                             ^^^^^^^^^^
+note: required because it appears within the type `impl Sized`
+  --> tests/ui/spawn_nonsend.rs:7:1
+   |
+7  | #[embassy_executor::task]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+note: required by a bound in `SendSpawner::spawn`
+  --> src/spawner.rs
+   |
+   |     pub fn spawn<S: Send>(&self, token: SpawnToken<S>) {
+   |                     ^^^^ required by this bound in `SendSpawner::spawn`
+   = note: this error originates in the attribute macro `embassy_executor::task` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/embassy-executor/tests/ui/task_safety_attribute.rs b/embassy-executor/tests/ui/task_safety_attribute.rs
new file mode 100644
index 000000000..ab5a2f99f
--- /dev/null
+++ b/embassy-executor/tests/ui/task_safety_attribute.rs
@@ -0,0 +1,25 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+#![deny(unused_unsafe)]
+
+use std::mem;
+
+#[embassy_executor::task]
+async fn safe() {}
+
+#[embassy_executor::task]
+async unsafe fn not_safe() {}
+
+#[export_name = "__pender"]
+fn pender(_: *mut ()) {
+    // The test doesn't link if we don't include this.
+    // We never call this anyway.
+}
+
+fn main() {
+    let _forget_me = safe();
+    // SAFETY: not_safe has not safety preconditions
+    let _forget_me2 = unsafe { not_safe() };
+
+    mem::forget(_forget_me);
+    mem::forget(_forget_me2);
+}
diff --git a/embassy-executor/tests/ui/unsafe_op_in_unsafe_task.rs b/embassy-executor/tests/ui/unsafe_op_in_unsafe_task.rs
new file mode 100644
index 000000000..ee7924838
--- /dev/null
+++ b/embassy-executor/tests/ui/unsafe_op_in_unsafe_task.rs
@@ -0,0 +1,10 @@
+#![cfg_attr(feature = "nightly", feature(impl_trait_in_assoc_type))]
+#![deny(unsafe_op_in_unsafe_fn)]
+
+#[embassy_executor::task]
+async unsafe fn task() {
+    let x = 5;
+    (&x as *const i32).read();
+}
+
+fn main() {}
diff --git a/embassy-executor/tests/ui/unsafe_op_in_unsafe_task.stderr b/embassy-executor/tests/ui/unsafe_op_in_unsafe_task.stderr
new file mode 100644
index 000000000..d987a4b95
--- /dev/null
+++ b/embassy-executor/tests/ui/unsafe_op_in_unsafe_task.stderr
@@ -0,0 +1,18 @@
+error[E0133]: call to unsafe function `std::ptr::const_ptr::<impl *const T>::read` is unsafe and requires unsafe block
+ --> tests/ui/unsafe_op_in_unsafe_task.rs:7:5
+  |
+7 |     (&x as *const i32).read();
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+  |
+  = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
+  = note: consult the function's documentation for information on how to avoid undefined behavior
+note: an unsafe function restricts its caller, but its body is safe by default
+ --> tests/ui/unsafe_op_in_unsafe_task.rs:5:1
+  |
+5 | async unsafe fn task() {
+  | ^^^^^^^^^^^^^^^^^^^^^^
+note: the lint level is defined here
+ --> tests/ui/unsafe_op_in_unsafe_task.rs:2:9
+  |
+2 | #![deny(unsafe_op_in_unsafe_fn)]
+  |         ^^^^^^^^^^^^^^^^^^^^^^