Remove cfg_target_has_atomic! macro (#2439)

Author: taiki-e

.github/workflows/ci.yml

@@ -246,8 +246,8 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: Install Rust
-        run: rustup update stable && rustup default stable
-      - run: tools/fmt.sh
+        run: rustup update stable
+      - run: cargo fmt --all -- --check
 
   docs:
     name: cargo doc

ci/no_atomic_cas.sh

@@ -1,5 +1,10 @@
 #!/bin/bash
 
+# Update the list of targets that do not support atomic CAS operations.
+#
+# Usage:
+#    ./ci/no_atomic_cas.sh
+
 set -euo pipefail
 IFS=$'\n\t'
 

futures-channel/build.rs

@@ -8,7 +8,7 @@ include!("no_atomic_cas.rs");
 // and outside of the normal semver guarantees:
 //
 // - `futures_no_atomic_cas`
-//      Assume the target does not have atomic CAS (compare-and-swap).
+//      Assume the target does *not* support atomic CAS operations.
 //      This is usually detected automatically by the build script, but you may
 //      need to enable it manually when building for custom targets or using
 //      non-cargo build systems that don't run the build script.

futures-channel/src/lib.rs

@@ -18,21 +18,16 @@
 #![warn(clippy::all)]
 #![doc(test(attr(deny(warnings), allow(dead_code, unused_assignments, unused_variables))))]
 
-macro_rules! cfg_target_has_atomic {
-    ($($item:item)*) => {$(
-        #[cfg(not(futures_no_atomic_cas))]
-        $item
-    )*};
-}
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+extern crate alloc;
 
-cfg_target_has_atomic! {
-    #[cfg(feature = "alloc")]
-    extern crate alloc;
-
-    #[cfg(feature = "alloc")]
-    mod lock;
-    #[cfg(feature = "std")]
-    pub mod mpsc;
-    #[cfg(feature = "alloc")]
-    pub mod oneshot;
-}
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+mod lock;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "std")]
+pub mod mpsc;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub mod oneshot;

futures-core/build.rs

@@ -8,7 +8,7 @@ include!("no_atomic_cas.rs");
 // and outside of the normal semver guarantees:
 //
 // - `futures_no_atomic_cas`
-//      Assume the target does not have atomic CAS (compare-and-swap).
+//      Assume the target does *not* support atomic CAS operations.
 //      This is usually detected automatically by the build script, but you may
 //      need to enable it manually when building for custom targets or using
 //      non-cargo build systems that don't run the build script.

futures-task/build.rs

@@ -8,7 +8,7 @@ include!("no_atomic_cas.rs");
 // and outside of the normal semver guarantees:
 //
 // - `futures_no_atomic_cas`
-//      Assume the target does not have atomic CAS (compare-and-swap).
+//      Assume the target does *not* support atomic CAS operations.
 //      This is usually detected automatically by the build script, but you may
 //      need to enable it manually when building for custom targets or using
 //      non-cargo build systems that don't run the build script.

futures-task/src/lib.rs

@@ -10,32 +10,29 @@
 #[cfg(feature = "alloc")]
 extern crate alloc;
 
-macro_rules! cfg_target_has_atomic {
-    ($($item:item)*) => {$(
-        #[cfg(not(futures_no_atomic_cas))]
-        $item
-    )*};
-}
-
 mod spawn;
 pub use crate::spawn::{LocalSpawn, Spawn, SpawnError};
 
-cfg_target_has_atomic! {
-    #[cfg(feature = "alloc")]
-    mod arc_wake;
-    #[cfg(feature = "alloc")]
-    pub use crate::arc_wake::ArcWake;
-
-    #[cfg(feature = "alloc")]
-    mod waker;
-    #[cfg(feature = "alloc")]
-    pub use crate::waker::waker;
-
-    #[cfg(feature = "alloc")]
-    mod waker_ref;
-    #[cfg(feature = "alloc")]
-    pub use crate::waker_ref::{waker_ref, WakerRef};
-}
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+mod arc_wake;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub use crate::arc_wake::ArcWake;
+
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+mod waker;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub use crate::waker::waker;
+
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+mod waker_ref;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub use crate::waker_ref::{waker_ref, WakerRef};
 
 mod future_obj;
 pub use crate::future_obj::{FutureObj, LocalFutureObj, UnsafeFutureObj};

futures-task/src/spawn.rs

@@ -168,27 +168,25 @@ mod if_alloc {
         }
     }
 
-    cfg_target_has_atomic! {
-        use alloc::{ sync::Arc };
-
-        impl<Sp: ?Sized + Spawn> Spawn for Arc<Sp> {
-            fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
-                (**self).spawn_obj(future)
-            }
+    #[cfg(not(futures_no_atomic_cas))]
+    impl<Sp: ?Sized + Spawn> Spawn for alloc::sync::Arc<Sp> {
+        fn spawn_obj(&self, future: FutureObj<'static, ()>) -> Result<(), SpawnError> {
+            (**self).spawn_obj(future)
+        }
 
-            fn status(&self) -> Result<(), SpawnError> {
-                (**self).status()
-            }
+        fn status(&self) -> Result<(), SpawnError> {
+            (**self).status()
         }
+    }
 
-        impl<Sp: ?Sized + LocalSpawn> LocalSpawn for Arc<Sp> {
-            fn spawn_local_obj(&self, future: LocalFutureObj<'static, ()>) -> Result<(), SpawnError> {
-                (**self).spawn_local_obj(future)
-            }
+    #[cfg(not(futures_no_atomic_cas))]
+    impl<Sp: ?Sized + LocalSpawn> LocalSpawn for alloc::sync::Arc<Sp> {
+        fn spawn_local_obj(&self, future: LocalFutureObj<'static, ()>) -> Result<(), SpawnError> {
+            (**self).spawn_local_obj(future)
+        }
 
-            fn status_local(&self) -> Result<(), SpawnError> {
-                (**self).status_local()
-            }
+        fn status_local(&self) -> Result<(), SpawnError> {
+            (**self).status_local()
         }
     }
 }

futures-util/build.rs

@@ -9,7 +9,7 @@ include!("no_atomic_cas.rs");
 // and outside of the normal semver guarantees:
 //
 // - `futures_no_atomic_cas`
-//      Assume the target does not have atomic CAS (compare-and-swap).
+//      Assume the target does *not* support atomic CAS operations.
 //      This is usually detected automatically by the build script, but you may
 //      need to enable it manually when building for custom targets or using
 //      non-cargo build systems that don't run the build script.

futures-util/src/future/mod.rs

@@ -106,14 +106,15 @@ pub use self::select_ok::{select_ok, SelectOk};
 mod either;
 pub use self::either::Either;
 
-cfg_target_has_atomic! {
-    #[cfg(feature = "alloc")]
-    mod abortable;
-    #[cfg(feature = "alloc")]
-    pub use crate::abortable::{Abortable, AbortHandle, AbortRegistration, Aborted};
-    #[cfg(feature = "alloc")]
-    pub use abortable::abortable;
-}
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+mod abortable;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub use crate::abortable::{AbortHandle, AbortRegistration, Abortable, Aborted};
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub use abortable::abortable;
 
 // Just a helper function to ensure the futures we're returning all have the
 // right implementations.

futures-util/src/lib.rs

@@ -47,13 +47,6 @@ pub mod __private {
     }
 }
 
-macro_rules! cfg_target_has_atomic {
-    ($($item:item)*) => {$(
-        #[cfg(not(futures_no_atomic_cas))]
-        $item
-    )*};
-}
-
 #[cfg(feature = "sink")]
 macro_rules! delegate_sink {
     ($field:ident, $item:ty) => {
@@ -334,10 +327,9 @@ pub use crate::io::{
 #[cfg(feature = "alloc")]
 pub mod lock;
 
-cfg_target_has_atomic! {
-    #[cfg(feature = "alloc")]
-    mod abortable;
-}
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+mod abortable;
 
 mod fns;
 mod unfold_state;

futures-util/src/lock/mod.rs

@@ -3,20 +3,23 @@
 //! This module is only available when the `std` or `alloc` feature of this
 //! library is activated, and it is activated by default.
 
-cfg_target_has_atomic! {
-    #[cfg(feature = "std")]
-    mod mutex;
-    #[cfg(feature = "std")]
-    pub use self::mutex::{MappedMutexGuard, Mutex, MutexLockFuture, MutexGuard};
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "std")]
+mod mutex;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "std")]
+pub use self::mutex::{MappedMutexGuard, Mutex, MutexGuard, MutexLockFuture};
 
-    #[cfg(any(feature = "bilock", feature = "sink", feature = "io"))]
-    #[cfg_attr(docsrs, doc(cfg(feature = "bilock")))]
-    #[cfg_attr(not(feature = "bilock"), allow(unreachable_pub))]
-    mod bilock;
-    #[cfg(feature = "bilock")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "bilock")))]
-    pub use self::bilock::{BiLock, BiLockAcquire, BiLockGuard, ReuniteError};
-    #[cfg(any(feature = "sink", feature = "io"))]
-    #[cfg(not(feature = "bilock"))]
-    pub(crate) use self::bilock::BiLock;
-}
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(any(feature = "bilock", feature = "sink", feature = "io"))]
+#[cfg_attr(docsrs, doc(cfg(feature = "bilock")))]
+#[cfg_attr(not(feature = "bilock"), allow(unreachable_pub))]
+mod bilock;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(any(feature = "sink", feature = "io"))]
+#[cfg(not(feature = "bilock"))]
+pub(crate) use self::bilock::BiLock;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "bilock")]
+#[cfg_attr(docsrs, doc(cfg(feature = "bilock")))]
+pub use self::bilock::{BiLock, BiLockAcquire, BiLockGuard, ReuniteError};

futures-util/src/stream/mod.rs

@@ -92,30 +92,37 @@ pub use self::select::{select, Select};
 mod unfold;
 pub use self::unfold::{unfold, Unfold};
 
-cfg_target_has_atomic! {
-    #[cfg(feature = "alloc")]
-    mod futures_ordered;
-    #[cfg(feature = "alloc")]
-    pub use self::futures_ordered::FuturesOrdered;
-
-    #[cfg(feature = "alloc")]
-    pub mod futures_unordered;
-    #[cfg(feature = "alloc")]
-    #[doc(inline)]
-    pub use self::futures_unordered::FuturesUnordered;
-
-    #[cfg(feature = "alloc")]
-    pub mod select_all;
-    #[cfg(feature = "alloc")]
-    pub use self::select_all::{select_all, SelectAll};
-
-    #[cfg(feature = "alloc")]
-    mod abortable;
-    #[cfg(feature = "alloc")]
-    pub use crate::abortable::{Abortable, AbortHandle, AbortRegistration, Aborted};
-    #[cfg(feature = "alloc")]
-    pub use abortable::abortable;
-}
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+mod futures_ordered;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub use self::futures_ordered::FuturesOrdered;
+
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub mod futures_unordered;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+#[doc(inline)]
+pub use self::futures_unordered::FuturesUnordered;
+
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub mod select_all;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub use self::select_all::{select_all, SelectAll};
+
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+mod abortable;
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub use crate::abortable::{AbortHandle, AbortRegistration, Abortable, Aborted};
+#[cfg(not(futures_no_atomic_cas))]
+#[cfg(feature = "alloc")]
+pub use abortable::abortable;
 
 // Just a helper function to ensure the streams we're returning all have the
 // right implementations.