Remove ATOMIC_U8_REF_INIT and static_atomic_ref

Author: yvt

src/lib.rs

@@ -39,9 +39,7 @@
 //! }
 //!
 //! // The methods for working with our currently defined static logger
-//! static_atomic_ref! {
-//!     static LOGGER: AtomicRef<LoggerInfo>;
-//! }
+//! static LOGGER: AtomicRef<LoggerInfo> = AtomicRef::new(None);
 //! fn log(msg: &str) -> bool {
 //!     if let Some(info) = LOGGER.load(Ordering::SeqCst) {
 //!         info.logger.log(msg);
@@ -73,7 +71,6 @@
 //! ```
 #![no_std]
 
-
 use core::sync::atomic::{AtomicPtr, Ordering};
 use core::marker::PhantomData;
 use core::fmt;
@@ -92,91 +89,11 @@ pub struct AtomicRef<'a, T: 'a> {
 // `#![feature(const_fn)]`
 struct Invariant<'a, T: 'a>(&'a mut &'a mut T);
 
-/// You will probably never need to use this type. It exists mostly for internal
-/// use in the `static_atomic_ref!` macro.
-///
-/// Unlike `AtomicUsize` and its ilk, we cannot have an `ATOMIC_REF_INIT` const
-/// which is initialized to `None`, as constants cannot be generic over a type
-/// parameter. This is the same reason why `AtomicPtr` does not have an
-/// `ATOMIC_PTR_INIT` const.
-///
-/// Instead, we have a single const for `&'static u8`, and take advantage of the
-/// fact that all AtomicRef types have identical layout to implement the
-/// `static_atomic_ref!` macro.
-///
-/// Please use `static_atomic_ref!` instead of this constant if you need to
-/// implement a static atomic reference variable.
-pub const ATOMIC_U8_REF_INIT: AtomicRef<'static, u8> = AtomicRef {
-    data: AtomicPtr::new(null_mut()),
-    _marker: PhantomData,
-};
-
 /// Re-export `core` for `static_atomic_ref!` (which may be used in a
 /// non-`no_std` crate, where `core` is unavailable).
 #[doc(hidden)]
 pub use core::{mem as core_mem, ops as core_ops};
 
-/// A macro to define a statically allocated `AtomicRef<'static, T>` which is
-/// initialized to `None`.
-///
-/// # Examples
-///
-/// ```
-/// # #[macro_use]
-/// # extern crate atomic_ref;
-/// use std::sync::atomic::Ordering;
-///
-/// static_atomic_ref! {
-///     static SOME_REFERENCE: AtomicRef<i32>;
-///     pub static PUB_REFERENCE: AtomicRef<u64>;
-/// }
-///
-/// fn main() {
-///     let a: Option<&'static i32> = SOME_REFERENCE.load(Ordering::SeqCst);
-///     assert_eq!(a, None);
-/// }
-/// ```
-#[macro_export]
-macro_rules! static_atomic_ref {
-    ($(#[$attr:meta])* static $N:ident : AtomicRef<$T:ty>; $($t:tt)*) => {
-        static_atomic_ref!(@PRIV, $(#[$attr])* static $N : $T; $($t)*);
-    };
-    ($(#[$attr:meta])* pub static $N:ident : AtomicRef<$T:ty>; $($t:tt)*) => {
-        static_atomic_ref!(@PUB, $(#[$attr])* static $N : $T; $($t)*);
-    };
-    (@$VIS:ident, $(#[$attr:meta])* static $N:ident : $T:ty; $($t:tt)*) => {
-        static_atomic_ref!(@MAKE TY, $VIS, $(#[$attr])*, $N);
-        impl $crate::core_ops::Deref for $N {
-            type Target = $crate::AtomicRef<'static, $T>;
-            #[allow(unsafe_code)]
-            fn deref<'a>(&'a self) -> &'a $crate::AtomicRef<'static, $T> {
-                static STORAGE: $crate::AtomicRef<'static, u8> = $crate::ATOMIC_U8_REF_INIT;
-                unsafe { $crate::core_mem::transmute(&STORAGE) }
-            }
-        }
-        static_atomic_ref!($($t)*);
-    };
-    (@MAKE TY, PUB, $(#[$attr:meta])*, $N:ident) => {
-        #[allow(missing_copy_implementations)]
-        #[allow(non_camel_case_types)]
-        #[allow(dead_code)]
-        $(#[$attr])*
-        pub struct $N { _private: () }
-        #[doc(hidden)]
-        pub static $N: $N = $N { _private: () };
-    };
-    (@MAKE TY, PRIV, $(#[$attr:meta])*, $N:ident) => {
-        #[allow(missing_copy_implementations)]
-        #[allow(non_camel_case_types)]
-        #[allow(dead_code)]
-        $(#[$attr])*
-        struct $N { _private: () }
-        #[doc(hidden)]
-        static $N: $N = $N { _private: () };
-    };
-    () => ();
-}
-
 /// An internal helper function for converting `Option<&'a T>` values to
 /// `*mut T` for storing in the `AtomicUsize`.
 const fn from_opt<'a, T>(p: Option<&'a T>) -> *mut T {
@@ -416,10 +333,9 @@ impl<'a, T> Default for AtomicRef<'a, T> {
 #[cfg(test)]
 mod tests {
     use core::sync::atomic::Ordering;
+    use super::AtomicRef;
 
-    static_atomic_ref! {
-        static FOO: AtomicRef<i32>;
-    }
+    static FOO: AtomicRef<i32> = AtomicRef::new(None);
 
     static A: i32 = 10;