Address reviews

Author: Veykril

src/cancelled.rs

@@ -11,7 +11,7 @@ use std::panic::{self, UnwindSafe};
 #[non_exhaustive]
 pub enum Cancelled {
     /// The query was operating but the local database execution has been cancelled.
-    Cancelled,
+    Local,
 
     /// The query was operating on revision R, but there is a pending write to move to revision R+1.
     PendingWrite,
@@ -46,7 +46,7 @@ impl Cancelled {
 impl std::fmt::Display for Cancelled {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let why = match self {
-            Cancelled::Cancelled => "canellation request",
+            Cancelled::Local => "local canellation request",
             Cancelled::PendingWrite => "pending write",
             Cancelled::PropagatedPanic => "propagated panic",
         };

src/database.rs

@@ -68,7 +68,7 @@ pub trait Database: Send + ZalsaDatabase + AsDynDatabase {
         let _ = self.zalsa_mut();
     }
 
-    /// Retrives a [`CancellationToken`] for the current database.
+    /// Retrieves a [`CancellationToken`] for the current database handle.
     fn cancellation_token(&self) -> CancellationToken {
         self.zalsa_local().cancellation_token()
     }

src/function/fetch.rs

@@ -105,39 +105,37 @@ where
     ) -> Option<&'db Memo<'db, C>> {
         let database_key_index = self.database_key_index(id);
         // Try to claim this query: if someone else has claimed it already, go back and start again.
-        let claim_guard = loop {
-            match self
-                .sync_table
-                .try_claim(zalsa, zalsa_local, id, Reentrancy::Allow)
-            {
-                ClaimResult::Claimed(guard) => break guard,
-                ClaimResult::Running(blocked_on) => {
-                    if !blocked_on.block_on(zalsa) {
-                        continue;
-                    }
+        let claim_guard = match self
+            .sync_table
+            .try_claim(zalsa, zalsa_local, id, Reentrancy::Allow)
+        {
+            ClaimResult::Claimed(guard) => guard,
+            ClaimResult::Running(blocked_on) => {
+                if !blocked_on.block_on(zalsa) {
+                    return None;
+                }
 
-                    if C::CYCLE_STRATEGY == CycleRecoveryStrategy::FallbackImmediate {
-                        let memo = self.get_memo_from_table_for(zalsa, id, memo_ingredient_index);
+                if C::CYCLE_STRATEGY == CycleRecoveryStrategy::FallbackImmediate {
+                    let memo = self.get_memo_from_table_for(zalsa, id, memo_ingredient_index);
 
-                        if let Some(memo) = memo {
-                            if memo.value.is_some() {
-                                memo.block_on_heads(zalsa);
-                            }
+                    if let Some(memo) = memo {
+                        if memo.value.is_some() {
+                            memo.block_on_heads(zalsa);
                         }
                     }
-
-                    return None;
-                }
-                ClaimResult::Cycle { .. } => {
-                    return Some(self.fetch_cold_cycle(
-                        zalsa,
-                        zalsa_local,
-                        db,
-                        id,
-                        database_key_index,
-                        memo_ingredient_index,
-                    ));
                 }
+
+                return None;
+            }
+            ClaimResult::Cycle { .. } => {
+                return Some(self.fetch_cold_cycle(
+                    zalsa,
+                    zalsa_local,
+                    db,
+                    id,
+                    database_key_index,
+                    memo_ingredient_index,
+                ));
             }
         };
 

src/function/maybe_changed_after.rs

@@ -141,16 +141,15 @@ where
     ) -> Option<VerifyResult> {
         let database_key_index = self.database_key_index(key_index);
 
-        let claim_guard = loop {
+        let claim_guard =
             match self
                 .sync_table
                 .try_claim(zalsa, zalsa_local, key_index, Reentrancy::Deny)
             {
-                ClaimResult::Claimed(guard) => break guard,
+                ClaimResult::Claimed(guard) => guard,
                 ClaimResult::Running(blocked_on) => {
-                    if blocked_on.block_on(zalsa) {
-                        return None;
-                    }
+                    _ = blocked_on.block_on(zalsa);
+                    return None;
                 }
                 ClaimResult::Cycle { .. } => {
                     return Some(self.maybe_changed_after_cold_cycle(
@@ -159,8 +158,7 @@ where
                         cycle_heads,
                     ))
                 }
-            }
-        };
+            };
         // Load the current memo, if any.
         let Some(old_memo) = self.get_memo_from_table_for(zalsa, key_index, memo_ingredient_index)
         else {

src/runtime.rs

@@ -125,7 +125,6 @@ impl Running<'_> {
     ///
     /// Returns `true` if the computation was successful, and `false` if the other thread was cancelled.
     #[must_use]
-    #[cold]
     pub(crate) fn block_on(self, zalsa: &Zalsa) -> bool {
         let BlockedOnInner {
             dg,

src/zalsa_local.rs

@@ -448,7 +448,7 @@ impl ZalsaLocal {
 
     #[cold]
     pub(crate) fn unwind_cancelled(&self) {
-        Cancelled::Cancelled.throw();
+        Cancelled::Local.throw();
     }
 }
 

tests/cancellation_token.rs

@@ -44,7 +44,7 @@ fn cancellation_token() {
             a(&db, input)
         })
     });
-    assert!(matches!(res, Err(Cancelled::Cancelled)), "{res:?}");
+    assert!(matches!(res, Err(Cancelled::Local)), "{res:?}");
     drop(res);
     db.assert_logs(expect![[r#"
         [

tests/parallel/cancellation_token_recomputes.rs

@@ -38,6 +38,6 @@ fn execute() {
     db_signaler.signal(3);
     let (r1, r2) = (t1.join(), t2.join());
     let r1 = *r1.unwrap_err().downcast::<salsa::Cancelled>().unwrap();
-    assert!(matches!(r1, Cancelled::Cancelled), "{r1:?}");
+    assert!(matches!(r1, Cancelled::Local), "{r1:?}");
     assert_eq!(r2.unwrap(), 1);
 }