Fix reference counting in DispatchSemaphoreGuard::release

Author: andyleiserson

crates/dispatch2/src/semaphore.rs

@@ -39,10 +39,14 @@ pub struct DispatchSemaphoreGuard(DispatchRetained<DispatchSemaphore>);
 impl DispatchSemaphoreGuard {
     /// Release the [`DispatchSemaphore`].
     pub fn release(self) -> bool {
-        let this = ManuallyDrop::new(self);
+        // Extract the inner `DispatchRetained` so that it will be dropped independently of
+        // `self`. SAFETY: `self.0` is a valid `DispatchRetained`.
+        let semaphore: DispatchRetained<DispatchSemaphore> = unsafe {
+            DispatchRetained::from_raw(DispatchRetained::as_ptr(&ManuallyDrop::new(self).0))
+        };
 
         // SAFETY: DispatchSemaphore cannot be null.
-        let result = this.0.signal();
+        let result = semaphore.signal();
 
         result != 0
     }
@@ -54,3 +58,33 @@ impl Drop for DispatchSemaphoreGuard {
         self.0.signal();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use objc2::msg_send;
+
+    fn retain_count(semaphore: &DispatchSemaphore) -> usize {
+        // SAFETY: semaphore is valid and the method signature is correct.
+        unsafe { msg_send![semaphore, retainCount] }
+    }
+
+    #[test]
+    fn acquire_release() {
+        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);
+    }
+}