Change has_atomic_cas to no_atomic_cas to implement the first workaround

rust-lang · Dec 31, 2020 · c0e926c · c0e926c
1 parent 665c32e
commit c0e926c
Show file tree

Hide file tree

Showing 14 changed files with 259 additions and 32 deletions.
diff --git a/futures-channel/build.rs b/futures-channel/build.rs
@@ -16,8 +16,12 @@ fn main() {
         }
     };
 
-    if cfg.probe_expression("core::sync::atomic::AtomicPtr::<()>::compare_exchange") {
-        println!("cargo:rustc-cfg=has_atomic_cas");
+    // Note that this is `no_atomic_cas`, not `has_atomic_cas`. This allows to
+    // treat `cfg(target_has_atomic = "ptr")` as true when the build script
+    // doesn't run. This is needed for compatibility with non-cargo build
+    // systems that don't run build scripts.
+    if !cfg.probe_expression("core::sync::atomic::AtomicPtr::<()>::compare_exchange") {
+        println!("cargo:rustc-cfg=no_atomic_cas");
     }
     println!("cargo:rerun-if-changed=build.rs");
 }
diff --git a/futures-channel/src/lib.rs b/futures-channel/src/lib.rs
@@ -22,7 +22,7 @@
 
 macro_rules! cfg_target_has_atomic {
     ($($item:item)*) => {$(
-        #[cfg(has_atomic_cas)]
+        #[cfg(not(no_atomic_cas))]
         $item
     )*};
 }

diff --git a/futures-core/build.rs b/futures-core/build.rs
@@ -16,8 +16,12 @@ fn main() {
         }
     };
 
-    if cfg.probe_expression("core::sync::atomic::AtomicPtr::<()>::compare_exchange") {
-        println!("cargo:rustc-cfg=has_atomic_cas");
+    // Note that this is `no_atomic_cas`, not `has_atomic_cas`. This allows to
+    // treat `cfg(target_has_atomic = "ptr")` as true when the build script
+    // doesn't run. This is needed for compatibility with non-cargo build
+    // systems that don't run build scripts.
+    if !cfg.probe_expression("core::sync::atomic::AtomicPtr::<()>::compare_exchange") {
+        println!("cargo:rustc-cfg=no_atomic_cas");
     }
     println!("cargo:rerun-if-changed=build.rs");
 }
diff --git a/futures-core/src/task/__internal/mod.rs b/futures-core/src/task/__internal/mod.rs
@@ -1,4 +1,4 @@
-#[cfg(has_atomic_cas)]
+#[cfg(not(no_atomic_cas))]
 mod atomic_waker;
-#[cfg(has_atomic_cas)]
+#[cfg(not(no_atomic_cas))]
 pub use self::atomic_waker::AtomicWaker;
diff --git a/futures-task/build.rs b/futures-task/build.rs
@@ -16,8 +16,12 @@ fn main() {
         }
     };
 
-    if cfg.probe_expression("core::sync::atomic::AtomicPtr::<()>::compare_exchange") {
-        println!("cargo:rustc-cfg=has_atomic_cas");
+    // Note that this is `no_atomic_cas`, not `has_atomic_cas`. This allows to
+    // treat `cfg(target_has_atomic = "ptr")` as true when the build script
+    // doesn't run. This is needed for compatibility with non-cargo build
+    // systems that don't run build scripts.
+    if !cfg.probe_expression("core::sync::atomic::AtomicPtr::<()>::compare_exchange") {
+        println!("cargo:rustc-cfg=no_atomic_cas");
     }
     println!("cargo:rerun-if-changed=build.rs");
 }
diff --git a/futures-task/src/lib.rs b/futures-task/src/lib.rs
@@ -19,7 +19,7 @@ extern crate alloc;
 
 macro_rules! cfg_target_has_atomic {
     ($($item:item)*) => {$(
-        #[cfg(has_atomic_cas)]
+        #[cfg(not(no_atomic_cas))]
         $item
     )*};
 }

diff --git a/futures-task/src/spawn2.rs b/futures-task/src/spawn2.rs
@@ -0,0 +1,207 @@
+use crate::{FutureObj, LocalFutureObj};
+use core::fmt;
+use std::{future::Future, pin::Pin};
+
+/// The `Spawn` trait allows for pushing futures onto an executor that will
+/// run them to completion.
+pub trait Spawn {
+    type Handle;
+    /// An error that occurred during spawning.
+    type Error;
+
+    /// Spawns a future that will be run to completion.
+    ///
+    /// # Errors
+    ///
+    /// The executor may be unable to spawn tasks. Spawn errors should
+    /// represent relatively rare scenarios, such as the executor
+    /// having been shut down so that it is no longer able to accept
+    /// tasks.
+    fn spawn_boxed(
+        &self,
+        future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+    ) -> Result<Self::Handle, Self::Error>;
+
+    /// Determines whether the executor is able to spawn new tasks.
+    ///
+    /// This method will return `Ok` when the executor is *likely*
+    /// (but not guaranteed) to accept a subsequent spawn attempt.
+    /// Likewise, an `Err` return means that `spawn` is likely, but
+    /// not guaranteed, to yield an error.
+    #[inline]
+    fn status(&self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+/// The `LocalSpawn` is similar to [`Spawn`], but allows spawning futures
+/// that don't implement `Send`.
+pub trait LocalSpawn {
+    type Handle;
+    /// An error that occurred during spawning.
+    type Error;
+
+    /// Spawns a future that will be run to completion.
+    ///
+    /// # Errors
+    ///
+    /// The executor may be unable to spawn tasks. Spawn errors should
+    /// represent relatively rare scenarios, such as the executor
+    /// having been shut down so that it is no longer able to accept
+    /// tasks.
+    fn spawn_local_boxed(
+        &self,
+        future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+    ) -> Result<Self::Handle, Self::Error>;
+
+    /// Determines whether the executor is able to spawn new tasks.
+    ///
+    /// This method will return `Ok` when the executor is *likely*
+    /// (but not guaranteed) to accept a subsequent spawn attempt.
+    /// Likewise, an `Err` return means that `spawn` is likely, but
+    /// not guaranteed, to yield an error.
+    #[inline]
+    fn status_local(&self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+impl<Sp: ?Sized + Spawn> Spawn for &Sp {
+    fn spawn_boxed(
+        &self,
+        future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+    ) -> Result<Self::Handle, Self::Error> {
+        Sp::spawn_obj(self, future)
+    }
+
+    fn status(&self) -> Result<(), Self::Error> {
+        Sp::status(self)
+    }
+}
+
+impl<Sp: ?Sized + Spawn> Spawn for &mut Sp {
+    fn spawn_boxed(
+        &self,
+        future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+    ) -> Result<Self::Handle, Self::Error> {
+        Sp::spawn_obj(self, future)
+    }
+
+    fn status(&self) -> Result<(), Self::Error> {
+        Sp::status(self)
+    }
+}
+
+impl<Sp: ?Sized + LocalSpawn> LocalSpawn for &Sp {
+    fn spawn_local_boxed(
+        &self,
+        future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+    ) -> Result<Self::Handle, Self::Error> {
+        Sp::spawn_local_boxed(self, future)
+    }
+
+    fn status_local(&self) -> Result<(), Self::Error> {
+        Sp::status_local(self)
+    }
+}
+
+impl<Sp: ?Sized + LocalSpawn> LocalSpawn for &mut Sp {
+    fn spawn_local_boxed(
+        &self,
+        future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+    ) -> Result<Self::Handle, Self::Error> {
+        Sp::spawn_local_boxed(self, future)
+    }
+
+    fn status_local(&self) -> Result<(), Self::Error> {
+        Sp::status_local(self)
+    }
+}
+
+#[cfg(feature = "alloc")]
+mod if_alloc {
+    use super::*;
+    use alloc::{boxed::Box, rc::Rc};
+
+    impl<Sp: ?Sized + Spawn> Spawn for Box<Sp> {
+        fn spawn_boxed(
+            &self,
+            future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+        ) -> Result<Self::Handle, Self::Error> {
+            (**self).spawn_obj(future)
+        }
+
+        fn status(&self) -> Result<(), Self::Error> {
+            (**self).status()
+        }
+    }
+
+    impl<Sp: ?Sized + LocalSpawn> LocalSpawn for Box<Sp> {
+        fn spawn_local_boxed(
+            &self,
+            future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+        ) -> Result<Self::Handle, Self::Error> {
+            (**self).spawn_local_boxed(future)
+        }
+
+        fn status_local(&self) -> Result<(), Self::Error> {
+            (**self).status_local()
+        }
+    }
+
+    impl<Sp: ?Sized + Spawn> Spawn for Rc<Sp> {
+        fn spawn_boxed(
+            &self,
+            future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+        ) -> Result<Self::Handle, Self::Error> {
+            (**self).spawn_obj(future)
+        }
+
+        fn status(&self) -> Result<(), Self::Error> {
+            (**self).status()
+        }
+    }
+
+    impl<Sp: ?Sized + LocalSpawn> LocalSpawn for Rc<Sp> {
+        fn spawn_local_boxed(
+            &self,
+            future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+        ) -> Result<Self::Handle, Self::Error> {
+            (**self).spawn_local_boxed(future)
+        }
+
+        fn status_local(&self) -> Result<(), Self::Error> {
+            (**self).status_local()
+        }
+    }
+
+    cfg_target_has_atomic! {
+        use alloc::sync::Arc;
+
+        impl<Sp: ?Sized + Spawn> Spawn for Arc<Sp> {
+            fn spawn_boxed(
+                &self,
+                future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+            ) -> Result<Self::Handle, Self::Error> {
+                (**self).spawn_obj(future)
+            }
+
+            fn status(&self) -> Result<(), Self::Error> {
+                (**self).status()
+            }
+        }
+
+        impl<Sp: ?Sized + LocalSpawn> LocalSpawn for Arc<Sp> {
+            fn spawn_local_boxed(
+                &self,
+                future: Pin<Box<dyn Future<Output = ()> + Send + 'static>>,
+            ) -> Result<Self::Handle, Self::Error> {
+                (**self).spawn_local_boxed(future)
+            }
+
+            fn status_local(&self) -> Result<(), Self::Error> {
+                (**self).status_local()
+            }
+        }
+    }
+}
diff --git a/futures-util/build.rs b/futures-util/build.rs
@@ -16,8 +16,12 @@ fn main() {
         }
     };
 
-    if cfg.probe_expression("core::sync::atomic::AtomicPtr::<()>::compare_exchange") {
-        println!("cargo:rustc-cfg=has_atomic_cas");
+    // Note that this is `no_atomic_cas`, not `has_atomic_cas`. This allows to
+    // treat `cfg(target_has_atomic = "ptr")` as true when the build script
+    // doesn't run. This is needed for compatibility with non-cargo build
+    // systems that don't run build scripts.
+    if !cfg.probe_expression("core::sync::atomic::AtomicPtr::<()>::compare_exchange") {
+        println!("cargo:rustc-cfg=no_atomic_cas");
     }
     println!("cargo:rerun-if-changed=build.rs");
 }
diff --git a/futures-util/src/lib.rs b/futures-util/src/lib.rs
@@ -57,7 +57,7 @@ pub mod __private {
 
 macro_rules! cfg_target_has_atomic {
     ($($item:item)*) => {$(
-        #[cfg(has_atomic_cas)]
+        #[cfg(not(no_atomic_cas))]
         $item
     )*};
 }

diff --git a/futures-util/src/stream/mod.rs b/futures-util/src/stream/mod.rs
@@ -31,11 +31,11 @@ pub use self::stream::ReadyChunks;
 #[cfg_attr(docsrs, doc(cfg(feature = "sink")))]
 pub use self::stream::Forward;
 
-#[cfg(has_atomic_cas)]
+#[cfg(not(no_atomic_cas))]
 #[cfg(feature = "alloc")]
 pub use self::stream::{BufferUnordered, Buffered, ForEachConcurrent};
 
-#[cfg(has_atomic_cas)]
+#[cfg(not(no_atomic_cas))]
 #[cfg(feature = "sink")]
 #[cfg_attr(docsrs, doc(cfg(feature = "sink")))]
 #[cfg(feature = "alloc")]
@@ -53,7 +53,7 @@ pub use self::try_stream::{
 #[cfg(feature = "std")]
 pub use self::try_stream::IntoAsyncRead;
 
-#[cfg(has_atomic_cas)]
+#[cfg(not(no_atomic_cas))]
 #[cfg(feature = "alloc")]
 pub use self::try_stream::{TryBufferUnordered, TryBuffered, TryForEachConcurrent};
 

diff --git a/futures-util/src/stream/stream/mod.rs b/futures-util/src/stream/stream/mod.rs
@@ -917,7 +917,7 @@ pub trait StreamExt: Stream {
     /// fut.await;
     /// # })
     /// ```
-    #[cfg(has_atomic_cas)]
+    #[cfg(not(no_atomic_cas))]
     #[cfg(feature = "alloc")]
     fn for_each_concurrent<Fut, F>(
         self,
@@ -1140,7 +1140,7 @@ pub trait StreamExt: Stream {
     ///
     /// This method is only available when the `std` or `alloc` feature of this
     /// library is activated, and it is activated by default.
-    #[cfg(has_atomic_cas)]
+    #[cfg(not(no_atomic_cas))]
     #[cfg(feature = "alloc")]
     fn buffered(self, n: usize) -> Buffered<Self>
     where
@@ -1185,7 +1185,7 @@ pub trait StreamExt: Stream {
     /// assert_eq!(buffered.next().await, None);
     /// # Ok::<(), i32>(()) }).unwrap();
     /// ```
-    #[cfg(has_atomic_cas)]
+    #[cfg(not(no_atomic_cas))]
     #[cfg(feature = "alloc")]
     fn buffer_unordered(self, n: usize) -> BufferUnordered<Self>
     where
@@ -1349,7 +1349,7 @@ pub trait StreamExt: Stream {
     /// library is activated, and it is activated by default.
     #[cfg(feature = "sink")]
     #[cfg_attr(docsrs, doc(cfg(feature = "sink")))]
-    #[cfg(has_atomic_cas)]
+    #[cfg(not(no_atomic_cas))]
     #[cfg(feature = "alloc")]
     fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>)
     where

diff --git a/futures-util/src/stream/try_stream/mod.rs b/futures-util/src/stream/try_stream/mod.rs
@@ -515,7 +515,7 @@ pub trait TryStreamExt: TryStream {
     /// assert_eq!(Err(oneshot::Canceled), fut.await);
     /// # })
     /// ```
-    #[cfg(has_atomic_cas)]
+    #[cfg(not(no_atomic_cas))]
     #[cfg(feature = "alloc")]
     fn try_for_each_concurrent<Fut, F>(
         self,
@@ -836,7 +836,7 @@ pub trait TryStreamExt: TryStream {
     /// assert_eq!(buffered.next().await, Some(Err("error in the stream")));
     /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
     /// ```
-    #[cfg(has_atomic_cas)]
+    #[cfg(not(no_atomic_cas))]
     #[cfg(feature = "alloc")]
     fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self>
     where
@@ -912,7 +912,7 @@ pub trait TryStreamExt: TryStream {
     /// assert_eq!(buffered.next().await, Some(Err("error in the stream")));
     /// # Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();
     /// ```
-    #[cfg(has_atomic_cas)]
+    #[cfg(not(no_atomic_cas))]
     #[cfg(feature = "alloc")]
     fn try_buffered(self, n: usize) -> TryBuffered<Self>
     where