fix: Fix deadlock introduced in 0b71083

src/rwlock/raw.rs

@@ -539,12 +539,14 @@ impl<'a> Future for RawUpgrade<'a> {
 }
 
 impl<'a> Drop for RawUpgrade<'a> {
+    #[inline]
     fn drop(&mut self) {
         if let Some(lock) = self.lock {
-            // Unset `WRITER_BIT`.
-            lock.state.fetch_and(!WRITER_BIT, Ordering::SeqCst);
-            // Trigger the "no writer" event.
-            lock.no_writer.notify(1);
+            // SAFETY: we are dropping the future that would give us a write lock,
+            // so we don't need said lock anymore.
+            unsafe {
+                lock.write_unlock();
+            }
         }
     }
 }

tests/rwlock.rs

@@ -278,6 +278,35 @@ fn yields_when_contended() {
     );
 }
 
+#[test]
+fn cancellation() {
+    future::block_on(async {
+        let rw = RwLock::new(());
+
+        drop(rw.read());
+
+        drop(rw.upgradable_read());
+
+        drop(rw.write());
+
+        let read = rw.read().await;
+        drop(read);
+
+        let upgradable_read = rw.upgradable_read().await;
+        drop(upgradable_read);
+
+        let write = rw.write().await;
+        drop(write);
+
+        let upgradable_read = rw.upgradable_read().await;
+        drop(RwLockUpgradableReadGuard::upgrade(upgradable_read));
+
+        let upgradable_read = rw.upgradable_read().await;
+        let write = RwLockUpgradableReadGuard::upgrade(upgradable_read).await;
+        drop(write);
+    });
+}
+
 // We are testing that this compiles.
 fn _covariance_test<'g>(guard: RwLockReadGuard<'g, &'static ()>) {
     let _: RwLockReadGuard<'g, &'g ()> = guard;