use generic Atomic type where possible

in core/alloc/std only for now, and ignoring test files

library/alloc/src/collections/binary_heap/tests.rs

@@ -507,9 +507,9 @@ fn panic_safe() {
     use rand::seq::SliceRandom;
     use std::cmp;
     use std::panic::{self, AssertUnwindSafe};
-    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::atomic::{Atomic, AtomicUsize, Ordering};
 
-    static DROP_COUNTER: AtomicUsize = AtomicUsize::new(0);
+    static DROP_COUNTER: Atomic<usize> = AtomicUsize::new(0);
 
     #[derive(Eq, PartialEq, Ord, Clone, Debug)]
     struct PanicOrd<T>(T, bool);

library/alloc/src/collections/btree/map/tests.rs

@@ -10,7 +10,7 @@ use core::assert_matches::assert_matches;
 use std::iter;
 use std::ops::Bound::{Excluded, Included, Unbounded};
 use std::panic::{catch_unwind, AssertUnwindSafe};
-use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+use std::sync::atomic::{Atomic, AtomicUsize, Ordering::SeqCst};
 
 // Minimum number of elements to insert, to guarantee a tree with 2 levels,
 // i.e., a tree who's root is an internal node at height 1, with edges to leaf nodes.
@@ -782,7 +782,7 @@ fn test_range_finding_ill_order_in_range_ord() {
         }
     }
 
-    static COMPARES: AtomicUsize = AtomicUsize::new(0);
+    static COMPARES: Atomic<usize> = AtomicUsize::new(0);
     impl Ord for EvilTwin {
         fn cmp(&self, other: &Self) -> Ordering {
             let ord = self.0.cmp(&other.0);

library/alloc/src/lib.rs

@@ -125,6 +125,7 @@
 #![feature(extend_one)]
 #![feature(fmt_internals)]
 #![feature(fn_traits)]
+#![feature(generic_atomic)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(hint_assert_unchecked)]
 #![feature(inplace_iteration)]

library/alloc/src/slice/tests.rs

@@ -9,7 +9,7 @@ use core::cmp::Ordering::{self, Equal, Greater, Less};
 use core::convert::identity;
 use core::fmt;
 use core::mem;
-use core::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+use core::sync::atomic::{Atomic, AtomicUsize, Ordering::Relaxed};
 use rand::{distributions::Standard, prelude::*, Rng, RngCore};
 use std::panic;
 
@@ -62,91 +62,9 @@ macro_rules! do_test {
 
 const MAX_LEN: usize = 80;
 
-static DROP_COUNTS: [AtomicUsize; MAX_LEN] = [
-    // FIXME(RFC 1109): AtomicUsize is not Copy.
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-    AtomicUsize::new(0),
-];
-
-static VERSIONS: AtomicUsize = AtomicUsize::new(0);
+static DROP_COUNTS: [Atomic<usize>; MAX_LEN] = [const { AtomicUsize::new(0) }; MAX_LEN];
+
+static VERSIONS: Atomic<usize> = AtomicUsize::new(0);
 
 #[derive(Clone, Eq)]
 struct DropCounter {

library/alloc/src/sync.rs

@@ -25,8 +25,8 @@ use core::pin::Pin;
 use core::ptr::{self, NonNull};
 #[cfg(not(no_global_oom_handling))]
 use core::slice::from_raw_parts_mut;
-use core::sync::atomic;
 use core::sync::atomic::Ordering::{Acquire, Relaxed, Release};
+use core::sync::atomic::{self, Atomic};
 
 #[cfg(not(no_global_oom_handling))]
 use crate::alloc::handle_alloc_error;
@@ -352,12 +352,12 @@ impl<T: ?Sized> fmt::Debug for Weak<T> {
 // inner types.
 #[repr(C)]
 struct ArcInner<T: ?Sized> {
-    strong: atomic::AtomicUsize,
+    strong: Atomic<usize>,
 
     // the value usize::MAX acts as a sentinel for temporarily "locking" the
     // ability to upgrade weak pointers or downgrade strong ones; this is used
     // to avoid races in `make_mut` and `get_mut`.
-    weak: atomic::AtomicUsize,
+    weak: Atomic<usize>,
 
     data: T,
 }
@@ -2646,8 +2646,8 @@ impl<T, A: Allocator> Weak<T, A> {
 /// Helper type to allow accessing the reference counts without
 /// making any assertions about the data field.
 struct WeakInner<'a> {
-    weak: &'a atomic::AtomicUsize,
-    strong: &'a atomic::AtomicUsize,
+    weak: &'a Atomic<usize>,
+    strong: &'a Atomic<usize>,
 }
 
 impl<T: ?Sized> Weak<T> {

library/core/src/sync/atomic.rs

@@ -485,7 +485,7 @@ pub enum Ordering {
     note = "the `new` function is now preferred",
     suggestion = "AtomicBool::new(false)"
 )]
-pub const ATOMIC_BOOL_INIT: AtomicBool = AtomicBool::new(false);
+pub const ATOMIC_BOOL_INIT: Atomic<bool> = AtomicBool::new(false);
 
 #[cfg(target_has_atomic_load_store = "8")]
 impl AtomicBool {
@@ -3335,7 +3335,7 @@ macro_rules! atomic_int_ptr_sized {
             note = "the `new` function is now preferred",
             suggestion = "AtomicIsize::new(0)",
         )]
-        pub const ATOMIC_ISIZE_INIT: AtomicIsize = AtomicIsize::new(0);
+        pub const ATOMIC_ISIZE_INIT: Atomic<isize> = AtomicIsize::new(0);
 
         /// An [`AtomicUsize`] initialized to `0`.
         #[cfg(target_pointer_width = $target_pointer_width)]
@@ -3345,7 +3345,7 @@ macro_rules! atomic_int_ptr_sized {
             note = "the `new` function is now preferred",
             suggestion = "AtomicUsize::new(0)",
         )]
-        pub const ATOMIC_USIZE_INIT: AtomicUsize = AtomicUsize::new(0);
+        pub const ATOMIC_USIZE_INIT: Atomic<usize> = AtomicUsize::new(0);
     )* };
 }
 

library/std/src/alloc.rs

@@ -58,7 +58,7 @@
 
 use core::hint;
 use core::ptr::NonNull;
-use core::sync::atomic::{AtomicPtr, Ordering};
+use core::sync::atomic::{Atomic, AtomicPtr, Ordering};
 use core::{mem, ptr};
 
 #[stable(feature = "alloc_module", since = "1.28.0")]
@@ -288,7 +288,7 @@ unsafe impl Allocator for System {
     }
 }
 
-static HOOK: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
+static HOOK: Atomic<*mut ()> = AtomicPtr::new(ptr::null_mut());
 
 /// Registers a custom allocation error hook, replacing any that was previously registered.
 ///

library/std/src/backtrace.rs

@@ -93,7 +93,7 @@ use crate::env;
 use crate::ffi::c_void;
 use crate::fmt;
 use crate::panic::UnwindSafe;
-use crate::sync::atomic::{AtomicU8, Ordering::Relaxed};
+use crate::sync::atomic::{Atomic, AtomicU8, Ordering::Relaxed};
 use crate::sync::LazyLock;
 use crate::sys::backtrace::{lock, output_filename, set_image_base};
 
@@ -254,7 +254,7 @@ impl Backtrace {
         // Cache the result of reading the environment variables to make
         // backtrace captures speedy, because otherwise reading environment
         // variables every time can be somewhat slow.
-        static ENABLED: AtomicU8 = AtomicU8::new(0);
+        static ENABLED: Atomic<u8> = AtomicU8::new(0);
         match ENABLED.load(Relaxed) {
             0 => {}
             1 => return false,

library/std/src/io/stdio.rs

@@ -12,7 +12,7 @@ use crate::io::{
     self, BorrowedCursor, BufReader, IoSlice, IoSliceMut, LineWriter, Lines, SpecReadByte,
 };
 use crate::panic::{RefUnwindSafe, UnwindSafe};
-use crate::sync::atomic::{AtomicBool, Ordering};
+use crate::sync::atomic::{Atomic, AtomicBool, Ordering};
 use crate::sync::{Arc, Mutex, MutexGuard, OnceLock, ReentrantLock, ReentrantLockGuard};
 use crate::sys::stdio;
 use crate::thread::AccessError;
@@ -38,7 +38,7 @@ thread_local! {
 /// have a consistent order between set_output_capture and print_to *within
 /// the same thread*. Within the same thread, things always have a perfectly
 /// consistent order. So Ordering::Relaxed is fine.
-static OUTPUT_CAPTURE_USED: AtomicBool = AtomicBool::new(false);
+static OUTPUT_CAPTURE_USED: Atomic<bool> = AtomicBool::new(false);
 
 /// A handle to a raw instance of the standard input stream of this process.
 ///

library/std/src/lib.rs

@@ -333,6 +333,7 @@
 #![feature(float_minimum_maximum)]
 #![feature(float_next_up_down)]
 #![feature(fmt_internals)]
+#![feature(generic_atomic)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(hashmap_internals)]
 #![feature(hint_assert_unchecked)]

library/std/src/os/uefi/env.rs

@@ -2,14 +2,14 @@
 
 #![unstable(feature = "uefi_std", issue = "100499")]
 
-use crate::sync::atomic::{AtomicBool, AtomicPtr, Ordering};
+use crate::sync::atomic::{Atomic, AtomicBool, AtomicPtr, Ordering};
 use crate::{ffi::c_void, ptr::NonNull};
 
-static SYSTEM_TABLE: AtomicPtr<c_void> = AtomicPtr::new(crate::ptr::null_mut());
-static IMAGE_HANDLE: AtomicPtr<c_void> = AtomicPtr::new(crate::ptr::null_mut());
+static SYSTEM_TABLE: Atomic<*mut c_void> = AtomicPtr::new(crate::ptr::null_mut());
+static IMAGE_HANDLE: Atomic<*mut c_void> = AtomicPtr::new(crate::ptr::null_mut());
 // Flag to check if BootServices are still valid.
 // Start with assuming that they are not available
-static BOOT_SERVICES_FLAG: AtomicBool = AtomicBool::new(false);
+static BOOT_SERVICES_FLAG: Atomic<bool> = AtomicBool::new(false);
 
 /// Initializes the global System Table and Image Handle pointers.
 ///

library/std/src/os/xous/services.rs

@@ -1,5 +1,5 @@
 use crate::os::xous::ffi::Connection;
-use core::sync::atomic::{AtomicU32, Ordering};
+use core::sync::atomic::{Atomic, AtomicU32, Ordering};
 
 mod dns;
 pub(crate) use dns::*;
@@ -105,7 +105,7 @@ pub fn try_connect(name: &str) -> Option<Connection> {
     ns::try_connect_with_name(name)
 }
 
-static NAME_SERVER_CONNECTION: AtomicU32 = AtomicU32::new(0);
+static NAME_SERVER_CONNECTION: Atomic<u32> = AtomicU32::new(0);
 
 /// Return a `Connection` to the name server. If the name server has not been started,
 /// then this call will block until the name server has been started. The `Connection`

library/std/src/os/xous/services/dns.rs

@@ -1,6 +1,6 @@
 use crate::os::xous::ffi::Connection;
 use crate::os::xous::services::connect;
-use core::sync::atomic::{AtomicU32, Ordering};
+use core::sync::atomic::{Atomic, AtomicU32, Ordering};
 
 #[repr(usize)]
 pub(crate) enum DnsLendMut {
@@ -16,7 +16,7 @@ impl Into<usize> for DnsLendMut {
 /// Return a `Connection` to the DNS lookup server. This server is used for
 /// querying domain name values.
 pub(crate) fn dns_server() -> Connection {
-    static DNS_CONNECTION: AtomicU32 = AtomicU32::new(0);
+    static DNS_CONNECTION: Atomic<u32> = AtomicU32::new(0);
     let cid = DNS_CONNECTION.load(Ordering::Relaxed);
     if cid != 0 {
         return cid.into();

library/std/src/os/xous/services/log.rs

@@ -1,5 +1,5 @@
 use crate::os::xous::ffi::Connection;
-use core::sync::atomic::{AtomicU32, Ordering};
+use core::sync::atomic::{Atomic, AtomicU32, Ordering};
 
 /// Group `usize` bytes into a `usize` and return it, beginning
 /// from `offset` * sizeof(usize) bytes from the start. For example,
@@ -61,7 +61,7 @@ impl Into<usize> for LogLend {
 /// will block until the server is running. It is safe to call this multiple times,
 /// because the address is shared among all threads in a process.
 pub(crate) fn log_server() -> Connection {
-    static LOG_SERVER_CONNECTION: AtomicU32 = AtomicU32::new(0);
+    static LOG_SERVER_CONNECTION: Atomic<u32> = AtomicU32::new(0);
 
     let cid = LOG_SERVER_CONNECTION.load(Ordering::Relaxed);
     if cid != 0 {

library/std/src/os/xous/services/net.rs

@@ -1,6 +1,6 @@
 use crate::os::xous::ffi::Connection;
 use crate::os::xous::services::connect;
-use core::sync::atomic::{AtomicU32, Ordering};
+use core::sync::atomic::{Atomic, AtomicU32, Ordering};
 
 pub(crate) enum NetBlockingScalar {
     StdGetTtlUdp(u16 /* fd */),                /* 36 */
@@ -83,7 +83,7 @@ impl<'a> Into<[usize; 5]> for NetBlockingScalar {
 /// Return a `Connection` to the Network server. This server provides all
 /// OS-level networking functions.
 pub(crate) fn net_server() -> Connection {
-    static NET_CONNECTION: AtomicU32 = AtomicU32::new(0);
+    static NET_CONNECTION: Atomic<u32> = AtomicU32::new(0);
     let cid = NET_CONNECTION.load(Ordering::Relaxed);
     if cid != 0 {
         return cid.into();

library/std/src/os/xous/services/systime.rs

@@ -1,5 +1,5 @@
 use crate::os::xous::ffi::{connect, Connection};
-use core::sync::atomic::{AtomicU32, Ordering};
+use core::sync::atomic::{Atomic, AtomicU32, Ordering};
 
 pub(crate) enum SystimeScalar {
     GetUtcTimeMs,
@@ -16,7 +16,7 @@ impl Into<[usize; 5]> for SystimeScalar {
 /// Return a `Connection` to the systime server. This server is used for reporting the
 /// realtime clock.
 pub(crate) fn systime_server() -> Connection {
-    static SYSTIME_SERVER_CONNECTION: AtomicU32 = AtomicU32::new(0);
+    static SYSTIME_SERVER_CONNECTION: Atomic<u32> = AtomicU32::new(0);
     let cid = SYSTIME_SERVER_CONNECTION.load(Ordering::Relaxed);
     if cid != 0 {
         return cid.into();

library/std/src/os/xous/services/ticktimer.rs

@@ -1,5 +1,5 @@
 use crate::os::xous::ffi::Connection;
-use core::sync::atomic::{AtomicU32, Ordering};
+use core::sync::atomic::{Atomic, AtomicU32, Ordering};
 
 pub(crate) enum TicktimerScalar {
     ElapsedMs,
@@ -30,7 +30,7 @@ impl Into<[usize; 5]> for TicktimerScalar {
 /// Return a `Connection` to the ticktimer server. This server is used for synchronization
 /// primitives such as sleep, Mutex, and Condvar.
 pub(crate) fn ticktimer_server() -> Connection {
-    static TICKTIMER_SERVER_CONNECTION: AtomicU32 = AtomicU32::new(0);
+    static TICKTIMER_SERVER_CONNECTION: Atomic<u32> = AtomicU32::new(0);
     let cid = TICKTIMER_SERVER_CONNECTION.load(Ordering::Relaxed);
     if cid != 0 {
         return cid.into();