Simplify using lock_arc

The future returned by lock_arc would already resolve to a
MutexGuardArc that kept the Arc<Mutex> alive. Unfortunately, sometimes
one needs to store the future itself, not the MutexGuardArc and the
future had a reference to the Arc<Mutex>.

With this patch, the future itself also has a Arc<Mutex>.

src/mutex.rs

@@ -1,5 +1,6 @@
 use std::cell::UnsafeCell;
 use std::fmt;
+use std::future::Future;
 use std::ops::{Deref, DerefMut};
 use std::process;
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -263,6 +264,14 @@ impl<T: ?Sized> Mutex<T> {
 }
 
 impl<T: ?Sized> Mutex<T> {
+    async fn lock_arc_impl(self: Arc<Self>) -> MutexGuardArc<T> {
+        if let Some(guard) = self.try_lock_arc() {
+            return guard;
+        }
+        self.acquire_slow().await;
+        MutexGuardArc(self)
+    }
+
     /// Acquires the mutex and clones a reference to it.
     ///
     /// Returns an owned guard that releases the mutex when dropped.
@@ -280,12 +289,8 @@ impl<T: ?Sized> Mutex<T> {
     /// # })
     /// ```
     #[inline]
-    pub async fn lock_arc(self: &Arc<Self>) -> MutexGuardArc<T> {
-        if let Some(guard) = self.try_lock_arc() {
-            return guard;
-        }
-        self.acquire_slow().await;
-        MutexGuardArc(self.clone())
+    pub fn lock_arc(self: &Arc<Self>) -> impl Future<Output = MutexGuardArc<T>> {
+        self.clone().lock_arc_impl()
     }
 
     /// Attempts to acquire the mutex and clone a reference to it.

tests/mutex.rs

@@ -1,4 +1,3 @@
-#[cfg(not(target_arch = "wasm32"))]
 use std::sync::Arc;
 #[cfg(not(target_arch = "wasm32"))]
 use std::thread;
@@ -76,3 +75,12 @@ fn contention() {
         assert_eq!(num_tasks, *lock);
     });
 }
+
+#[test]
+fn lifetime() {
+    // Show that the future keeps the mutex alive.
+    let _fut = {
+        let mutex = Arc::new(Mutex::new(0i32));
+        mutex.lock_arc()
+    };
+}