Remove no default features from build (mattwparas#326)

mattwparas · web-flow · commit 8ecfa5e78f35 · 2025-03-13T21:54:29.000-07:00
* remove no default features from build

* rework mutex implementation
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
@@ -50,14 +50,14 @@ jobs:
           echo $STEEL_HOME
           mkdir -p .steel/cogs
           cd cogs/
-          cargo run --no-default-features -- install.scm
+          cargo run -- install.scm
 
       - uses: actions-rs/cargo@v1
         env:
           STEEL_HOME: ${{ env.STEEL_HOME }}
         with:
           command: test
-          args: --all --no-default-features
+          args: --all
 
       - name: install cargo-tarpaulin
         run: cargo install cargo-tarpaulin --force
diff --git a/crates/steel-core/src/scheme/modules/sync.scm b/crates/steel-core/src/scheme/modules/sync.scm
@@ -11,16 +11,16 @@
 ;; Lock the given lock during the duration
 ;; of the thunk.
 (define (lock! lock thunk)
-  (dynamic-wind (lambda () (lock-acquire! lock))
-                (lambda () (thunk))
-                (lambda () (lock-release! lock))))
+  (let ([lock-guard (lock-acquire! lock)])
+    (dynamic-wind (lambda () void) (lambda () (thunk)) (lambda () (lock-release! lock-guard)))))
 
 (struct ThreadPool (task-sender capacity thread-handles))
 
 (struct Task (lock done func-or-result err) #:mutable)
 
 (define *running* 'running)
 (define *waiting* 'waiting)
+(define *done* 'done)
 
 (define (task func)
   (Task (mutex) *waiting* func #f))
@@ -52,7 +52,7 @@
 
     ;; Does this work?
     (with-handler (lambda (err)
-                    (set-Task-done! next-task #t)
+                    (set-Task-done! next-task *done*)
                     (set-Task-err! next-task err))
                   ;; Capture exception, if it exists. Store it in the task
                   (lock! (Task-lock next-task)
@@ -61,7 +61,7 @@
                            ;; This should be fine, we're updating the task to be finished,
                            ;; so we can check the progress of it
                            (set-Task-func-or-result! next-task (func))
-                           (set-Task-done! next-task 'done))))
+                           (set-Task-done! next-task *done*))))
 
     (listen-for-tasks))
 
@@ -94,19 +94,14 @@
   (define (loop task)
     (cond
       [(equal? (Task-done task) *waiting*) (loop task)]
-
       [(equal? (Task-done task) *running*)
        (try-block task)
        (loop task)]
-
-      [(equal? (Task-done task) 'done)
+      [(equal? (Task-done task) *done*)
        (if (Task-err task)
            (Task-err task)
            (Task-func-or-result task))]
-
-      [else
-       (try-block task)
-       (loop task)]))
+      [else (loop task)]))
 
   (loop task))
 
diff --git a/crates/steel-core/src/steel_vm/vm/threads.rs b/crates/steel-core/src/steel_vm/vm/threads.rs
@@ -50,28 +50,37 @@ impl crate::rvals::Custom for ThreadHandle {}
 
 pub struct SteelMutex {
     mutex: Arc<parking_lot::Mutex<()>>,
-    guard: AtomicCell<Option<parking_lot::ArcMutexGuard<parking_lot::RawMutex, ()>>>,
 }
 
 impl crate::rvals::Custom for SteelMutex {}
 
+pub struct MutexGuard {
+    guard: AtomicCell<Option<parking_lot::ArcMutexGuard<parking_lot::RawMutex, ()>>>,
+}
+
+impl crate::rvals::Custom for MutexGuard {}
+
 impl SteelMutex {
     pub fn new() -> Self {
         Self {
             mutex: Arc::new(parking_lot::Mutex::new(())),
-            guard: AtomicCell::new(None),
         }
     }
 
     // Attempt to lock it before killing the other one
-    pub fn lock(&self) {
+    pub fn lock(&self) -> SteelVal {
         // Acquire the lock first
-        let guard = self.mutex.lock_arc();
-        self.guard.store(Some(guard));
+        MutexGuard {
+            guard: AtomicCell::new(Some(self.mutex.lock_arc())),
+        }
+        .into_steelval()
+        .unwrap()
     }
+}
 
+impl MutexGuard {
     pub fn unlock(&self) {
-        self.guard.store(None);
+        drop(self.guard.take());
     }
 }
 
@@ -85,14 +94,13 @@ pub fn new_mutex() -> Result<SteelVal> {
 /// with the `lock!` function.
 #[steel_derive::function(name = "lock-acquire!")]
 pub fn mutex_lock(mutex: &SteelVal) -> Result<SteelVal> {
-    SteelMutex::as_ref(mutex)?.lock();
-    Ok(SteelVal::Void)
+    Ok(SteelMutex::as_ref(mutex)?.lock())
 }
 
 /// Unlock the given mutex.
 #[steel_derive::function(name = "lock-release!")]
 pub fn mutex_unlock(mutex: &SteelVal) -> Result<SteelVal> {
-    SteelMutex::as_ref(mutex)?.unlock();
+    MutexGuard::as_ref(mutex)?.unlock();
     Ok(SteelVal::Void)
 }
 
