fix: [Local]SpawnExt should take &self as their base traits

Seems like an oversight in rust-lang#1950

Technically a

BREAKING CHANGE

futures-executor/src/local_pool.rs

@@ -60,7 +60,7 @@ impl ArcWake for ThreadNotify {
 fn run_executor<T, F: FnMut(&mut Context<'_>) -> Poll<T>>(mut f: F) -> T {
     let _enter = enter().expect(
         "cannot execute `LocalPool` executor from within \
-                 another executor",
+         another executor",
     );
 
     CURRENT_THREAD_NOTIFY.with(|thread_notify| {
@@ -78,7 +78,7 @@ fn run_executor<T, F: FnMut(&mut Context<'_>) -> Poll<T>>(mut f: F) -> T {
 fn poll_executor<T, F: FnMut(&mut Context<'_>) -> T>(mut f: F) -> T {
     let _enter = enter().expect(
         "cannot execute `LocalPool` executor from within \
-                 another executor",
+         another executor",
     );
 
     CURRENT_THREAD_NOTIFY.with(|thread_notify| {
@@ -161,7 +161,7 @@ impl LocalPool {
     /// use futures::future::{ready, pending};
     ///
     /// let mut pool = LocalPool::new();
-    /// let mut spawner = pool.spawner();
+    /// let spawner = pool.spawner();
     ///
     /// spawner.spawn_local(ready(())).unwrap();
     /// spawner.spawn_local(ready(())).unwrap();
@@ -209,7 +209,7 @@ impl LocalPool {
     /// use futures::future::{ready, pending};
     ///
     /// let mut pool = LocalPool::new();
-    /// let mut spawner = pool.spawner();
+    /// let spawner = pool.spawner();
     ///
     /// spawner.spawn_local(ready(())).unwrap();
     /// spawner.spawn_local(ready(())).unwrap();

futures-task/src/spawn.rs

@@ -83,6 +83,16 @@ impl SpawnError {
     }
 }
 
+impl<Sp: ?Sized + Spawn> Spawn for &Sp {
+    fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
+        Sp::spawn_obj(self, future)
+    }
+
+    fn status(&self) -> Result<(), SpawnError> {
+        Sp::status(self)
+    }
+}
+
 impl<Sp: ?Sized + Spawn> Spawn for &mut Sp {
     fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
         Sp::spawn_obj(self, future)
@@ -103,6 +113,16 @@ impl<Sp: ?Sized + LocalSpawn> LocalSpawn for &Sp {
     }
 }
 
+impl<Sp: ?Sized + LocalSpawn> LocalSpawn for &mut Sp {
+    fn spawn_local_obj(&self, future: LocalFutureObj<'static, ()>) -> Result<(), SpawnError> {
+        Sp::spawn_local_obj(self, future)
+    }
+
+    fn status_local(&self) -> Result<(), SpawnError> {
+        Sp::status_local(self)
+    }
+}
+
 #[cfg(feature = "alloc")]
 mod if_alloc {
     use super::*;

futures-test/src/task/noop_spawner.rs

@@ -9,7 +9,7 @@ use futures_task::{FutureObj, Spawn, SpawnError};
 /// use futures::task::SpawnExt;
 /// use futures_test::task::NoopSpawner;
 ///
-/// let mut spawner = NoopSpawner::new();
+/// let spawner = NoopSpawner::new();
 /// spawner.spawn(async { }).unwrap();
 /// ```
 #[derive(Debug)]

futures-test/src/task/panic_spawner.rs

@@ -9,7 +9,7 @@ use futures_task::{FutureObj, Spawn, SpawnError};
 /// use futures::task::SpawnExt;
 /// use futures_test::task::PanicSpawner;
 ///
-/// let mut spawn = PanicSpawner::new();
+/// let spawn = PanicSpawner::new();
 /// spawn.spawn(async { })?; // Will panic
 /// # Ok::<(), Box<dyn std::error::Error>>(())
 /// ```

futures-test/src/task/record_spawner.rs

@@ -10,7 +10,7 @@ use std::cell::{Ref, RefCell};
 /// use futures::task::SpawnExt;
 /// use futures_test::task::RecordSpawner;
 ///
-/// let mut recorder = RecordSpawner::new();
+/// let recorder = RecordSpawner::new();
 /// recorder.spawn(async { }).unwrap();
 /// assert_eq!(recorder.spawned().len(), 1);
 /// ```

futures-util/src/compat/executor.rs

@@ -24,7 +24,7 @@ pub trait Executor01CompatExt: Executor01<Executor01Future> + Clone + Send + 'st
     ///
     /// # let (tx, rx) = futures::channel::oneshot::channel();
     ///
-    /// let mut spawner = DefaultExecutor::current().compat();
+    /// let spawner = DefaultExecutor::current().compat();
     /// let future03 = async move {
     ///     println!("Running on the pool");
     ///     spawner.spawn(async {

futures-util/src/task/spawn.rs

@@ -37,13 +37,13 @@ pub trait SpawnExt: Spawn {
     /// use futures::executor::ThreadPool;
     /// use futures::task::SpawnExt;
     ///
-    /// let mut executor = ThreadPool::new().unwrap();
+    /// let executor = ThreadPool::new().unwrap();
     ///
     /// let future = async { /* ... */ };
     /// executor.spawn(future).unwrap();
     /// ```
     #[cfg(feature = "alloc")]
-    fn spawn<Fut>(&mut self, future: Fut) -> Result<(), SpawnError>
+    fn spawn<Fut>(&self, future: Fut) -> Result<(), SpawnError>
     where
         Fut: Future<Output = ()> + Send + 'static,
     {
@@ -62,18 +62,15 @@ pub trait SpawnExt: Spawn {
     /// use futures::future;
     /// use futures::task::SpawnExt;
     ///
-    /// let mut executor = ThreadPool::new().unwrap();
+    /// let executor = ThreadPool::new().unwrap();
     ///
     /// let future = future::ready(1);
     /// let join_handle_fut = executor.spawn_with_handle(future).unwrap();
     /// assert_eq!(block_on(join_handle_fut), 1);
     /// ```
     #[cfg(feature = "channel")]
     #[cfg(feature = "std")]
-    fn spawn_with_handle<Fut>(
-        &mut self,
-        future: Fut,
-    ) -> Result<RemoteHandle<Fut::Output>, SpawnError>
+    fn spawn_with_handle<Fut>(&self, future: Fut) -> Result<RemoteHandle<Fut::Output>, SpawnError>
     where
         Fut: Future + Send + 'static,
         Fut::Output: Send,
@@ -116,13 +113,13 @@ pub trait LocalSpawnExt: LocalSpawn {
     /// use futures::task::LocalSpawnExt;
     ///
     /// let executor = LocalPool::new();
-    /// let mut spawner = executor.spawner();
+    /// let spawner = executor.spawner();
     ///
     /// let future = async { /* ... */ };
     /// spawner.spawn_local(future).unwrap();
     /// ```
     #[cfg(feature = "alloc")]
-    fn spawn_local<Fut>(&mut self, future: Fut) -> Result<(), SpawnError>
+    fn spawn_local<Fut>(&self, future: Fut) -> Result<(), SpawnError>
     where
         Fut: Future<Output = ()> + 'static,
     {
@@ -141,7 +138,7 @@ pub trait LocalSpawnExt: LocalSpawn {
     /// use futures::task::LocalSpawnExt;
     ///
     /// let mut executor = LocalPool::new();
-    /// let mut spawner = executor.spawner();
+    /// let spawner = executor.spawner();
     ///
     /// let future = async { 1 };
     /// let join_handle_fut = spawner.spawn_local_with_handle(future).unwrap();
@@ -150,7 +147,7 @@ pub trait LocalSpawnExt: LocalSpawn {
     #[cfg(feature = "channel")]
     #[cfg(feature = "std")]
     fn spawn_local_with_handle<Fut>(
-        &mut self,
+        &self,
         future: Fut,
     ) -> Result<RemoteHandle<Fut::Output>, SpawnError>
     where

futures/tests/eventual.rs

@@ -6,7 +6,7 @@ use std::sync::mpsc;
 use std::thread;
 
 fn run<F: Future + Send + 'static>(future: F) {
-    let mut tp = ThreadPool::new().unwrap();
+    let tp = ThreadPool::new().unwrap();
     tp.spawn(future.map(drop)).unwrap();
 }
 

futures/tests/mutex.rs

@@ -37,7 +37,7 @@ fn mutex_wakes_waiters() {
 #[test]
 fn mutex_contested() {
     let (tx, mut rx) = mpsc::unbounded();
-    let mut pool = futures::executor::ThreadPool::builder().pool_size(16).create().unwrap();
+    let pool = futures::executor::ThreadPool::builder().pool_size(16).create().unwrap();
 
     let tx = Arc::new(tx);
     let mutex = Arc::new(Mutex::new(0));