Fix reference counting in DispatchSemaphoreGuard::release

Author: andyleiserson

crates/dispatch2/src/semaphore.rs

@@ -1,5 +1,3 @@
-use core::mem::ManuallyDrop;
-
 use crate::{DispatchObject, DispatchRetained};
 
 use crate::{DispatchTime, WaitError};
@@ -37,20 +35,58 @@ impl DispatchSemaphore {
 pub struct DispatchSemaphoreGuard(DispatchRetained<DispatchSemaphore>);
 
 impl DispatchSemaphoreGuard {
-    /// Release the [`DispatchSemaphore`].
-    pub fn release(self) -> bool {
-        let this = ManuallyDrop::new(self);
-
+    /// Signal the associated [`DispatchSemaphore`].
+    ///
+    /// This is an internal helper, called by wrappers that ensure it is called exactly
+    /// once, immediately prior to dropping the guard.
+    fn signal(&self) -> bool {
         // SAFETY: DispatchSemaphore cannot be null.
-        let result = this.0.signal();
+        self.0.signal() != 0
+    }
 
-        result != 0
+    /// Release the [`DispatchSemaphore`].
+    pub fn release(self) -> bool {
+        self.signal()
     }
 }
 
 impl Drop for DispatchSemaphoreGuard {
     fn drop(&mut self) {
-        // SAFETY: DispatchSemaphore cannot be null.
-        self.0.signal();
+        self.signal();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+
+    #[test]
+    #[cfg(feature = "objc2")]
+    #[cfg_attr(
+        not(target_vendor = "apple"),
+        ignore = "only Apple's libdisptch is interoperable with `objc2`"
+    )]
+    fn acquire_release() {
+        fn retain_count(semaphore: &DispatchSemaphore) -> usize {
+            // SAFETY: semaphore is valid and the method signature is correct.
+            unsafe { objc2::msg_send![semaphore, retainCount] }
+        }
+
+        let semaphore = DispatchSemaphore::new(1);
+
+        assert_eq!(retain_count(&semaphore), 1);
+        {
+            let _guard = semaphore.try_acquire(DispatchTime::NOW).unwrap();
+            assert_eq!(retain_count(&semaphore), 2);
+        }
+        assert_eq!(retain_count(&semaphore), 1);
+        {
+            let guard = semaphore.try_acquire(DispatchTime::NOW).unwrap();
+            assert_eq!(retain_count(&semaphore), 2);
+            guard.release();
+            assert_eq!(retain_count(&semaphore), 1);
+        }
+        assert_eq!(retain_count(&semaphore), 1);
     }
 }