Make into_inner const fn on Rust 1.56+

bench/benches/imp/spinlock_fallback.rs

@@ -109,11 +109,6 @@ macro_rules! atomic_int {
                 unsafe { &mut *self.v.get() }
             }
 
-            #[inline]
-            pub(crate) fn into_inner(self) -> $int_type {
-                self.v.into_inner()
-            }
-
             #[inline]
             #[cfg_attr(all(debug_assertions, not(portable_atomic_no_track_caller)), track_caller)]
             pub(crate) fn load(&self, order: Ordering) -> $int_type {

build.rs

@@ -74,6 +74,10 @@ fn main() {
     if !version.probe(52, 2021, 3, 10) {
         println!("cargo:rustc-cfg=portable_atomic_no_unsafe_op_in_unsafe_fn");
     }
+    // const_transmute stabilized in Rust 1.56 (nightly-2021-07-29): https://github.com/rust-lang/rust/pull/85769
+    if !version.probe(56, 2021, 7, 28) {
+        println!("cargo:rustc-cfg=portable_atomic_no_const_transmute");
+    }
     // https://github.com/rust-lang/rust/pull/84662 merged in Rust 1.56 (nightly-2021-08-02).
     if !version.probe(56, 2021, 8, 1) {
         println!("cargo:rustc-cfg=portable_atomic_no_core_unwind_safe");

src/imp/arm_linux.rs

@@ -287,11 +287,6 @@ macro_rules! atomic64 {
                 unsafe { &mut *self.v.get() }
             }
 
-            #[inline]
-            pub(crate) fn into_inner(self) -> $int_type {
-                self.v.into_inner()
-            }
-
             #[inline]
             #[cfg_attr(all(debug_assertions, not(portable_atomic_no_track_caller)), track_caller)]
             pub(crate) fn load(&self, order: Ordering) -> $int_type {

src/imp/atomic128/macros.rs

@@ -35,11 +35,6 @@ macro_rules! atomic128 {
                 unsafe { &mut *self.v.get() }
             }
 
-            #[inline]
-            pub(crate) fn into_inner(self) -> $int_type {
-                self.v.into_inner()
-            }
-
             #[inline]
             #[cfg_attr(
                 any(all(debug_assertions, not(portable_atomic_no_track_caller)), miri),

src/imp/core_atomic.rs

@@ -44,10 +44,6 @@ impl<T> AtomicPtr<T> {
         self.inner.get_mut()
     }
     #[inline]
-    pub(crate) fn into_inner(self) -> *mut T {
-        self.inner.into_inner()
-    }
-    #[inline]
     #[cfg_attr(
         any(all(debug_assertions, not(portable_atomic_no_track_caller)), miri),
         track_caller
@@ -174,10 +170,6 @@ macro_rules! atomic_int {
                 self.inner.get_mut()
             }
             #[inline]
-            pub(crate) fn into_inner(self) -> $int_type {
-                self.inner.into_inner()
-            }
-            #[inline]
             #[cfg_attr(
                 any(all(debug_assertions, not(portable_atomic_no_track_caller)), miri),
                 track_caller

src/imp/fallback/mod.rs

@@ -203,11 +203,6 @@ macro_rules! atomic {
                 unsafe { &mut *self.v.get() }
             }
 
-            #[inline]
-            pub(crate) fn into_inner(self) -> $int_type {
-                self.v.into_inner()
-            }
-
             #[inline]
             #[cfg_attr(all(debug_assertions, not(portable_atomic_no_track_caller)), track_caller)]
             pub(crate) fn load(&self, order: Ordering) -> $int_type {

src/imp/float.rs

@@ -54,11 +54,6 @@ macro_rules! atomic_float {
                 unsafe { &mut *self.v.get() }
             }
 
-            #[inline]
-            pub(crate) fn into_inner(self) -> $float_type {
-                self.v.into_inner()
-            }
-
             #[inline]
             #[cfg_attr(
                 any(all(debug_assertions, not(portable_atomic_no_track_caller)), miri),

src/imp/interrupt/mod.rs

@@ -139,11 +139,6 @@ impl<T> AtomicPtr<T> {
         unsafe { &mut *self.p.get() }
     }
 
-    #[inline]
-    pub(crate) fn into_inner(self) -> *mut T {
-        self.p.into_inner()
-    }
-
     #[inline]
     #[cfg_attr(all(debug_assertions, not(portable_atomic_no_track_caller)), track_caller)]
     pub(crate) fn load(&self, order: Ordering) -> *mut T {
@@ -276,11 +271,6 @@ macro_rules! atomic_int {
                 unsafe { &mut *self.v.get() }
             }
 
-            #[inline]
-            pub(crate) fn into_inner(self) -> $int_type {
-                self.v.into_inner()
-            }
-
             #[inline]
             pub(crate) const fn as_ptr(&self) -> *mut $int_type {
                 self.v.get()

src/imp/msp430.rs

@@ -99,12 +99,6 @@ macro_rules! atomic {
                 unsafe { &mut *self.v.get() }
             }
 
-            #[cfg(test)]
-            #[inline]
-            pub(crate) fn into_inner(self) -> $value_type {
-                 self.v.into_inner()
-            }
-
             #[inline]
             #[cfg_attr(all(debug_assertions, not(portable_atomic_no_track_caller)), track_caller)]
             pub(crate) fn load(&self, order: Ordering) -> $value_type {

src/imp/riscv.rs

@@ -153,11 +153,6 @@ macro_rules! atomic_load_store {
                 unsafe { &mut *self.v.get() }
             }
 
-            #[inline]
-            pub(crate) fn into_inner(self) -> $value_type {
-                 self.v.into_inner()
-            }
-
             #[inline]
             pub(crate) const fn as_ptr(&self) -> *mut $value_type {
                 self.v.get()

src/lib.rs

@@ -686,22 +686,30 @@ impl AtomicBool {
     // TODO: Add from_mut/get_mut_slice/from_mut_slice once it is stable on std atomic types.
     // https://github.com/rust-lang/rust/issues/76314
 
-    /// Consumes the atomic and returns the contained value.
-    ///
-    /// This is safe because passing `self` by value guarantees that no other threads are
-    /// concurrently accessing the atomic data.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use portable_atomic::AtomicBool;
-    ///
-    /// let some_bool = AtomicBool::new(true);
-    /// assert_eq!(some_bool.into_inner(), true);
-    /// ```
-    #[inline]
-    pub fn into_inner(self) -> bool {
-        self.v.into_inner() != 0
+    const_fn! {
+        const_if: #[cfg(not(portable_atomic_no_const_transmute))];
+        /// Consumes the atomic and returns the contained value.
+        ///
+        /// This is safe because passing `self` by value guarantees that no other threads are
+        /// concurrently accessing the atomic data.
+        ///
+        /// This is `const fn` on Rust 1.56+.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// use portable_atomic::AtomicBool;
+        ///
+        /// let some_bool = AtomicBool::new(true);
+        /// assert_eq!(some_bool.into_inner(), true);
+        /// ```
+        #[inline]
+        pub const fn into_inner(self) -> bool {
+            // SAFETY: AtomicBool and u8 have the same size and in-memory representations,
+            // so they can be safely transmuted.
+            // (const UnsafeCell::into_inner is unstable)
+            unsafe { core::mem::transmute::<AtomicBool, u8>(self) != 0 }
+        }
     }
 
     /// Loads a value from the bool.
@@ -1544,23 +1552,31 @@ impl<T> AtomicPtr<T> {
     // TODO: Add from_mut/get_mut_slice/from_mut_slice once it is stable on std atomic types.
     // https://github.com/rust-lang/rust/issues/76314
 
-    /// Consumes the atomic and returns the contained value.
-    ///
-    /// This is safe because passing `self` by value guarantees that no other threads are
-    /// concurrently accessing the atomic data.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use portable_atomic::AtomicPtr;
-    ///
-    /// let mut data = 5;
-    /// let atomic_ptr = AtomicPtr::new(&mut data);
-    /// assert_eq!(unsafe { *atomic_ptr.into_inner() }, 5);
-    /// ```
-    #[inline]
-    pub fn into_inner(self) -> *mut T {
-        self.inner.into_inner()
+    const_fn! {
+        const_if: #[cfg(not(portable_atomic_no_const_transmute))];
+        /// Consumes the atomic and returns the contained value.
+        ///
+        /// This is safe because passing `self` by value guarantees that no other threads are
+        /// concurrently accessing the atomic data.
+        ///
+        /// This is `const fn` on Rust 1.56+.
+        ///
+        /// # Examples
+        ///
+        /// ```
+        /// use portable_atomic::AtomicPtr;
+        ///
+        /// let mut data = 5;
+        /// let atomic_ptr = AtomicPtr::new(&mut data);
+        /// assert_eq!(unsafe { *atomic_ptr.into_inner() }, 5);
+        /// ```
+        #[inline]
+        pub const fn into_inner(self) -> *mut T {
+            // SAFETY: AtomicPtr<T> and *mut T have the same size and in-memory representations,
+            // so they can be safely transmuted.
+            // (const UnsafeCell::into_inner is unstable)
+            unsafe { core::mem::transmute(self) }
+        }
     }
 
     /// Loads a value from the pointer.
@@ -2539,12 +2555,40 @@ assert_eq!(some_var.load(Ordering::SeqCst), 5);
             // TODO: Add from_mut/get_mut_slice/from_mut_slice once it is stable on std atomic types.
             // https://github.com/rust-lang/rust/issues/76314
 
+            #[cfg(not(portable_atomic_no_const_transmute))]
+            doc_comment! {
+                concat!("Consumes the atomic and returns the contained value.
+
+This is safe because passing `self` by value guarantees that no other threads are
+concurrently accessing the atomic data.
+
+This is `const fn` on Rust 1.56+.
+
+# Examples
+
+```
+use portable_atomic::", stringify!($atomic_type), ";
+
+let some_var = ", stringify!($atomic_type), "::new(5);
+assert_eq!(some_var.into_inner(), 5);
+```"),
+                #[inline]
+                pub const fn into_inner(self) -> $int_type {
+                    // SAFETY: $atomic_type and $int_type have the same size and in-memory representations,
+                    // so they can be safely transmuted.
+                    // (const UnsafeCell::into_inner is unstable)
+                    unsafe { core::mem::transmute(self) }
+                }
+            }
+            #[cfg(portable_atomic_no_const_transmute)]
             doc_comment! {
                 concat!("Consumes the atomic and returns the contained value.
 
 This is safe because passing `self` by value guarantees that no other threads are
 concurrently accessing the atomic data.
 
+This is `const fn` on Rust 1.56+.
+
 # Examples
 
 ```
@@ -2555,7 +2599,10 @@ assert_eq!(some_var.into_inner(), 5);
 ```"),
                 #[inline]
                 pub fn into_inner(self) -> $int_type {
-                    self.inner.into_inner()
+                    // SAFETY: $atomic_type and $int_type have the same size and in-memory representations,
+                    // so they can be safely transmuted.
+                    // (const UnsafeCell::into_inner is unstable)
+                    unsafe { core::mem::transmute(self) }
                 }
             }
 
@@ -3607,13 +3654,21 @@ This type has the same in-memory representation as the underlying floating point
             // TODO: Add from_mut/get_mut_slice/from_mut_slice once it is stable on std atomic types.
             // https://github.com/rust-lang/rust/issues/76314
 
-            /// Consumes the atomic and returns the contained value.
-            ///
-            /// This is safe because passing `self` by value guarantees that no other threads are
-            /// concurrently accessing the atomic data.
-            #[inline]
-            pub fn into_inner(self) -> $float_type {
-                self.inner.into_inner()
+            const_fn! {
+                const_if: #[cfg(not(portable_atomic_no_const_transmute))];
+                /// Consumes the atomic and returns the contained value.
+                ///
+                /// This is safe because passing `self` by value guarantees that no other threads are
+                /// concurrently accessing the atomic data.
+                ///
+                /// This is `const fn` on Rust 1.56+.
+                #[inline]
+                pub const fn into_inner(self) -> $float_type {
+                    // SAFETY: $atomic_type and $float_type have the same size and in-memory representations,
+                    // so they can be safely transmuted.
+                    // (const UnsafeCell::into_inner is unstable)
+                    unsafe { core::mem::transmute(self) }
+                }
             }
 
             /// Loads a value from the atomic float.