chore: Fix CI issues

I also add a more expansive comment detailing the safety conditions of
our usage of `async-task`.

Signed-off-by: John Nunley <[email protected]>

Author: notgull

src/lib.rs

@@ -239,11 +239,30 @@ impl<'a> Executor<'a> {
         };
 
         // Create the task and register it in the set of active tasks.
-        let (runnable, task) = unsafe {
-            Builder::new()
-                .propagate_panic(true)
-                .spawn_unchecked(|()| future, self.schedule())
-        };
+        //
+        // SAFETY:
+        //
+        // If `future` is not `Send`, this must be a `LocalExecutor` as per this
+        // function's unsafe precondition. Since `LocalExecutor` is `!Sync`,
+        // `try_tick`, `tick` and `run` can only be called from the origin
+        // thread of the `LocalExecutor`. Similarly, `spawn` can only  be called
+        // from the origin thread, ensuring that `future` and the executor share
+        // the same origin thread. The `Runnable` can be scheduled from other
+        // threads, but because of the above `Runnable` can only be called or
+        // dropped on the origin thread.
+        //
+        // `future` is not `'static`, but we make sure that the `Runnable` does
+        // not outlive `'a`. When the executor is dropped, the `active` field is
+        // drained and all of the `Waker`s are woken. Then, the queue inside of
+        // the `Executor` is drained of all of its runnables. This ensures that
+        // runnables are dropped and this precondition is satisfied.
+        //
+        // `self.schedule()` is `Send`, `Sync` and `'static`, as checked below.
+        // Therefore we do not need to worry about what is done with the
+        // `Waker`.
+        let (runnable, task) = Builder::new()
+            .propagate_panic(true)
+            .spawn_unchecked(|()| future, self.schedule());
         entry.insert(runnable.waker());
 
         runnable.schedule();
@@ -1068,6 +1087,7 @@ fn _ensure_send_and_sync() {
 
     fn is_send<T: Send>(_: T) {}
     fn is_sync<T: Sync>(_: T) {}
+    fn is_static<T: 'static>(_: T) {}
 
     is_send::<Executor<'_>>(Executor::new());
     is_sync::<Executor<'_>>(Executor::new());
@@ -1077,6 +1097,9 @@ fn _ensure_send_and_sync() {
     is_sync(ex.run(pending::<()>()));
     is_send(ex.tick());
     is_sync(ex.tick());
+    is_send(ex.schedule());
+    is_sync(ex.schedule());
+    is_static(ex.schedule());
 
     /// ```compile_fail
     /// use async_executor::LocalExecutor;

tests/spawn_many.rs

@@ -8,7 +8,7 @@ fn spawn_many() {
 
         // Spawn a lot of tasks.
         let mut tasks = vec![];
-        ex.spawn_many((0..50_000).map(|i| future::ready(i)), &mut tasks);
+        ex.spawn_many((0..50_000).map(future::ready), &mut tasks);
 
         // Run all of the tasks in parallel.
         ex.run(async move {
@@ -27,7 +27,7 @@ fn spawn_many_local() {
 
         // Spawn a lot of tasks.
         let mut tasks = vec![];
-        ex.spawn_many((0..50_000).map(|i| future::ready(i)), &mut tasks);
+        ex.spawn_many((0..50_000).map(future::ready), &mut tasks);
 
         // Run all of the tasks in parallel.
         ex.run(async move {