refactor tests and helpers as requested

Author: Daniel-Aaron-Bloom

library/core/src/cell.rs

@@ -910,7 +910,7 @@ impl<T> RefCell<T> {
     #[rustc_confusables("swap")]
     #[rustc_const_unstable(feature = "const_ref_cell", issue = "137844")]
     pub const fn replace(&self, t: T) -> T {
-        mem::replace(self.borrow_mut().as_mut(), t)
+        mem::replace(&mut self.borrow_mut(), t)
     }
 
     /// Replaces the wrapped value with a new one computed from `f`, returning
@@ -962,7 +962,7 @@ impl<T> RefCell<T> {
     #[stable(feature = "refcell_swap", since = "1.24.0")]
     #[rustc_const_unstable(feature = "const_ref_cell", issue = "137844")]
     pub const fn swap(&self, other: &Self) {
-        mem::swap(self.borrow_mut().as_mut(), other.borrow_mut().as_mut())
+        mem::swap(&mut *self.borrow_mut(), &mut *other.borrow_mut())
     }
 }
 
@@ -1452,6 +1452,8 @@ impl<'b> BorrowRef<'b> {
             Some(BorrowRef { borrow })
         }
     }
+
+    /// `Clone` is not a `const_trait`, so work around that by making our own method
     #[inline]
     #[rustc_const_unstable(feature = "const_ref_cell", issue = "137844")]
     const fn clone(&self) -> Self {
@@ -1671,12 +1673,6 @@ impl<T: ?Sized + fmt::Display> fmt::Display for Ref<'_, T> {
 }
 
 impl<'b, T: ?Sized> RefMut<'b, T> {
-    #[inline]
-    const fn as_mut(&mut self) -> &mut T {
-        // SAFETY: the value is accessible as long as we hold our borrow.
-        unsafe { self.value.as_mut() }
-    }
-
     /// Makes a new `RefMut` for a component of the borrowed data, e.g., an enum
     /// variant.
     ///
@@ -1897,7 +1893,8 @@ pub struct RefMut<'b, T: ?Sized + 'b> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> Deref for RefMut<'_, T> {
+#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
+impl<T: ?Sized> const Deref for RefMut<'_, T> {
     type Target = T;
 
     #[inline]
@@ -1908,10 +1905,12 @@ impl<T: ?Sized> Deref for RefMut<'_, T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized> DerefMut for RefMut<'_, T> {
+#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
+impl<T: ?Sized> const DerefMut for RefMut<'_, T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut T {
-        self.as_mut()
+        // SAFETY: the value is accessible as long as we hold our borrow.
+        unsafe { self.value.as_mut() }
     }
 }
 

library/coretests/tests/cell.rs

@@ -1,4 +1,5 @@
 use core::cell::*;
+use core::mem::forget;
 
 #[test]
 fn smoketest_unsafe_cell() {
@@ -477,3 +478,42 @@ fn const_cells() {
         const _: i32 = CELL.into_inner();
     */
 }
+
+#[allow(dead_code)]
+fn const_refcell() {
+    struct Dummy;
+    impl Drop for Dummy {
+        fn drop(&mut self) {
+            panic!("should never be called");
+        }
+    }
+    // Check that `replace` is usable at compile-time
+    const REPLACE_TEST: u32 = {
+        let a = RefCell::new(0);
+        assert!(a.replace(10) == 0);
+        let a = a.into_inner();
+        assert!(a == 10);
+        a
+    };
+    const REPLACE_DUMMY_TEST: RefCell<Dummy> = {
+        let a = RefCell::new(Dummy);
+        forget(a.replace(Dummy));
+        a
+    };
+
+    // Check that `swap` is usable at compile-time
+    const SWAP_TEST: (u32, u32) = {
+        let (a, b) = (RefCell::new(31), RefCell::new(41));
+        a.swap(&b);
+        let (a, b) = (a.into_inner(), b.into_inner());
+        assert!(a == 41);
+        assert!(b == 31);
+        (a, b)
+    };
+    const SWAP_DUMMY_TEST: [RefCell<Dummy>; 2] = {
+        let a = RefCell::new(Dummy);
+        let b = RefCell::new(Dummy);
+        a.swap(&b);
+        [a, b]
+    };
+}

library/coretests/tests/lib.rs

@@ -16,6 +16,7 @@
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
 #![feature(const_eval_select)]
+#![feature(const_ref_cell)]
 #![feature(const_swap_nonoverlapping)]
 #![feature(const_trait_impl)]
 #![feature(core_intrinsics)]