Fix lint errors

Author: kezhuw

.github/workflows/ci.yml

@@ -98,7 +98,7 @@ jobs:
           override: true
           components: clippy
     - name: Lint code
-      run: cargo clippy --all-features --no-deps -- -D clippy::all
+      run: cargo clippy --all-targets --all-features --no-deps -- -D clippy::all
   release:
     if: github.event_name == 'push' && github.ref_type == 'tag'
     needs: [build, test, lint]

Makefile

@@ -11,7 +11,7 @@ check_fmt:
 	cargo +nightly fmt --all -- --check
 
 lint:
-	cargo clippy --all-features --no-deps -- -D clippy::all
+	cargo clippy --all-targets --all-features --no-deps -- -D clippy::all
 
 build:
 	cargo build-all-features

examples/echo.rs

@@ -17,11 +17,11 @@ mod echo {
             id_counter += 1;
             let id = id_counter;
             let handle = spawns::spawn(async move {
-                eprintln!("{:010}[{}]: serving", id, remote_addr);
+                eprintln!("{id:010}[{remote_addr}]: serving");
                 let (reader, writer) = io::split(stream);
                 match io::copy(reader, writer).await {
-                    Ok(_) => eprintln!("{:010}[{}]: closed", id, remote_addr),
-                    Err(err) => eprintln!("{:010}[{}]: {:?}", id, remote_addr, err),
+                    Ok(_) => eprintln!("{id:010}[{remote_addr}]: closed"),
+                    Err(err) => eprintln!("{id:010}[{remote_addr}]: {err:?}"),
                 }
             })
             .attach();

spawns-compat/src/tokio.rs

@@ -31,6 +31,7 @@ mod tests {
 
     #[tokio::test]
     async fn spawn_cascading() {
+        #[allow(clippy::async_yields_async)]
         let handle = spawn(async { spawn(async { id() }) });
         let handle = handle.await.unwrap();
         let id = handle.id();
@@ -39,6 +40,7 @@ mod tests {
 
     #[tokio::test]
     async fn spawn_interleaving() {
+        #[allow(clippy::async_yields_async)]
         let handle = spawn(async { tokio::spawn(async { spawn(async { id() }) }) });
         let handle = handle.await.unwrap().await.unwrap();
         let id = handle.id();
@@ -47,6 +49,7 @@ mod tests {
 
     #[tokio::test]
     async fn spawn_into_tokio() {
+        #[allow(clippy::async_yields_async)]
         let handle = spawn(async { tokio::spawn(async { try_id() }) });
         let handle = handle.await.unwrap();
         assert_eq!(handle.await.unwrap(), None);

spawns-core/src/spawn.rs

@@ -22,7 +22,10 @@ pub struct SpawnScope<'a> {
 
 fn exchange(spawner: Option<&dyn Spawn>) -> Option<&'static dyn Spawn> {
     SPAWNER.with_borrow_mut(|previous| unsafe {
-        std::mem::replace(previous, std::mem::transmute(spawner))
+        std::mem::replace(
+            previous,
+            std::mem::transmute::<Option<&dyn Spawn>, Option<&'static dyn Spawn>>(spawner),
+        )
     })
 }
 
@@ -148,6 +151,7 @@ mod tests {
     fn thread_spawner_cascading_ready() {
         let spawner = ThreadSpawner::default();
         let _scope = enter(&spawner);
+        #[allow(clippy::async_yields_async)]
         let handle = spawn(async move { spawn(async { id() }) });
         let handle = block_on(handle).unwrap();
         let id = handle.id();
@@ -158,6 +162,7 @@ mod tests {
     fn thread_spawner_cascading_cancel() {
         let spawner = ThreadSpawner::default();
         let _scope = enter(&spawner);
+        #[allow(clippy::async_yields_async)]
         let handle = spawn(async move { spawn(pending::<()>()) });
         let handle = block_on(handle).unwrap();
         handle.cancel();
@@ -172,7 +177,7 @@ mod tests {
         use linkme::distributed_slice;
         use std::cell::Cell;
         thread_local! {
-            static DROP_SPAWNER: Cell<Option<DropSpawner>> = Cell::new(None);
+            static DROP_SPAWNER: Cell<Option<DropSpawner>> = const {  Cell::new(None) };
         }
 
         #[distributed_slice(COMPATS)]
@@ -187,7 +192,7 @@ mod tests {
         }
 
         thread_local! {
-            static THREAD_SPAWNER: Cell<Option<ThreadSpawner>> = Cell::new(None);
+            static THREAD_SPAWNER: Cell<Option<ThreadSpawner>> = const { Cell::new(None) };
         }
 
         #[distributed_slice(COMPATS)]

spawns-core/src/task.rs

@@ -117,7 +117,7 @@ impl Display for Id {
 
 impl Debug for Id {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "TaskId({})", self)
+        write!(f, "TaskId({self})")
     }
 }
 
@@ -798,7 +798,7 @@ mod tests {
         handle.cancel();
         block_on(Box::into_pin(task.future));
         let err = block_on(handle).unwrap_err();
-        assert_eq!(err.is_cancelled(), true);
+        assert!(err.is_cancelled());
     }
 
     #[test]
@@ -807,15 +807,15 @@ mod tests {
         handle.cancel_handle().cancel();
         block_on(Box::into_pin(task.future));
         let err = block_on(handle).unwrap_err();
-        assert_eq!(err.is_cancelled(), true);
+        assert!(err.is_cancelled());
     }
 
     #[test]
     fn task_cancel_passively() {
         let (task, handle) = Task::new(Name::default(), ready(()));
         drop(task);
         let err = block_on(handle).unwrap_err();
-        assert_eq!(err.is_cancelled(), true);
+        assert!(err.is_cancelled());
     }
 
     #[test]
@@ -828,7 +828,7 @@ mod tests {
         handle.cancel();
         assert_eq!(task.as_mut().poll(&mut cx), Poll::Ready(()));
         let err = block_on(handle).unwrap_err();
-        assert_eq!(err.is_cancelled(), true);
+        assert!(err.is_cancelled());
     }
 
     #[test]
@@ -937,7 +937,7 @@ mod tests {
         });
         let handle = handle.attach();
         let err = block_on(async move { handle.cancel().await.unwrap_err() });
-        assert_eq!(err.is_cancelled(), true);
+        assert!(err.is_cancelled());
     }
 
     struct Sleep {
@@ -990,7 +990,7 @@ mod tests {
         let handle = handle.attach().detach();
         drop(handle);
         block_on(Box::into_pin(task.future));
-        assert_eq!(cancelled.load(Ordering::Relaxed), false);
+        assert!(!cancelled.load(Ordering::Relaxed));
     }
 
     struct CustomFuture {

spawns-executor/src/lib.rs

@@ -86,7 +86,7 @@ impl Blocking {
         let shutdown_signal = shutdown.wait_shutdown_triggered();
         (2..=threads).for_each(|i| {
             thread::Builder::new()
-                .name(format!("spawns-executor-{}/{}", i, threads))
+                .name(format!("spawns-executor-{i}/{threads}"))
                 .spawn({
                     let executor = executor.clone();
                     let shutdown_signal = shutdown_signal.clone();
@@ -147,7 +147,7 @@ mod tests {
 
         pub async fn echo_one(data: &[u8]) -> Vec<u8> {
             let (port, _server_handle) = start_echo_server().await;
-            let mut stream = TcpStream::connect(format!("127.0.0.1:{}", port))
+            let mut stream = TcpStream::connect(format!("127.0.0.1:{port}"))
                 .await
                 .unwrap();
             stream.write_all(data).await.unwrap();
@@ -176,6 +176,7 @@ mod tests {
     fn task_cancelled_after_main_return_current_thread() {
         use async_io::Timer;
         use std::time::Duration;
+        #[allow(clippy::async_yields_async)]
         let handle = block_on(async {
             spawns::spawn(async { Timer::after(Duration::from_secs(30)).await })
         });
@@ -187,6 +188,7 @@ mod tests {
     fn task_cancelled_after_main_return_multi_thread() {
         use async_io::Timer;
         use std::time::Duration;
+        #[allow(clippy::async_yields_async)]
         let handle = Blocking::new(4).block_on(async {
             spawns::spawn(async { Timer::after(Duration::from_secs(30)).await })
         });