firefly-compiler 0.5.35 → 0.5.37

package/core/Lock.ff

@@ -1,144 +1,108 @@
-capability Lock {}
-capability LockCondition {}
-
-extend self: Lock {
-
-    condition(): LockCondition
-        target js async """
-            return {lock: self_, stack: [], queue: []}
-        """
-
-    acquire(reentrant: Bool): Unit
-        target js async """
-            if(self_.level === 0) {
-                self_.owner = $task
-                self_.level += 1
-            } else {
-                if(self_.owner !== $task || !reentrant_) {
-                    try {
-                        await new Promise((resolve, reject) => {
-                            $task.controller.signal.addEventListener('abort', reject)
-                            try {
-                                self_.queue.push({owner: $task, resolve: resolve})
-                            } finally {
-                                $task.controller.signal.removeEventListener('abort', reject)
-                            }
-                        })
-                    } finally {
-                        if($task.controller.signal.aborted) $task.controller = new AbortController()
-                    }
-                } else {
-                    self_.level += 1
-                }
-            }
-        """
-    
-    release(): Unit
-        target js async """
-            if(self_.owner !== $task) {
-                throw new Error("Tried to release a lock without acquiring it first.")
-            } else if(self_.level > 1) {
-                self_.level -= 1
-            } else {
-                self_.owner = null
-                self_.level = 0
-                if(self_.stack.length === 0) {
-                    const empty = self_.stack
-                    self_.stack = self_.queue.reverse()
-                    self_.queue = empty
-                }
-                if(self_.stack.length !== 0) {
-                    const pending = self_.stack.pop()
-                    self_.owner = pending.owner
-                    self_.level = 1
-                    pending.resolve()
-                }
-            }
-        """
-    
-    do[T](reentrant: Bool, body: () => T): T {
-        self.acquire(reentrant)
-        try {
-            body()
-        } finally {
-            self.release()
-        }
-    }
-
-}
-
-extend self: LockCondition {
-
-    sleep(): Unit
-        target js async """
-            if(self_.lock.owner !== $task) {
-                throw new Error("Tried to sleep on a condition without acquiring it first.")
-            }
-            const level = self_.lock.level
-            self_.lock.level = 1
-            await ff_core_Lock.Lock_release$(self_.lock)
-            try {
-                await new Promise((resolve, reject) => {
-                    $task.controller.signal.addEventListener('abort', reject)
-                    try {
-                        self_.queue.push(resolve)
-                    } finally {
-                        $task.controller.signal.removeEventListener('abort', reject)
-                        if($task.controller.signal.aborted) $task.controller = new AbortController()
-                    }
-                })
-            } finally {
-                let exception = null
-                let acquired = false
-                while(!acquired) {
-                    try {
-                        await ff_core_Lock.Lock_acquire$(self_.lock)
-                        self_.lock.level = level
-                        acquired = true
-                    } catch(e) {
-                        exception = e
-                    }
-                }
-                if(e !== null) throw e;
-            }
-        """
-
-    sleepUntil[T](body: () => Option[T]): T {
-        body().{
-            | Some(value) =>
-                value
-            | None =>
-                self.sleep()
-                tailcall self.sleepUntil(body)
-        }
-    }
-
-    wakeOne(): Unit
-        target js async """
-            if(self_.stack.length === 0) {
-                const empty = self_.stack
-                self_.stack = self_.queue.reverse()
-                self_.queue = empty
-            }
-            if(self_.stack.length !== 0) {
-                const resolve = self_.stack.pop()
-                resolve()
-            }
-        """
-
-    wakeAll(): Unit
-        target js async """
-            while(self_.stack.length !== 0) {
-                const resolve = self_.stack.pop()
-                resolve()
-            }
-            const empty = self_.stack
-            self_.stack = self_.queue.reverse()
-            self_.queue = empty
-            while(self_.stack.length !== 0) {
-                const resolve = self_.stack.pop()
-                resolve()
-            }
-        """
-
-}
+capability Lock(
+    mutable owner: JsValue
+    mutable level: Int
+    queue: Queue[Pair[JsValue, Unit => Unit]]
+)
+
+capability LockCondition(
+    lock: Lock
+    queue: Queue[Unit => Unit]
+)
+
+extend self: Lock {
+
+    condition(): LockCondition {
+        LockCondition(self, Queue.new())
+    }
+    
+    acquire(): Unit {
+        if(self.level == 0 || self.owner === Js.currentTask()!) {
+            self.owner = Js.currentTask()!
+            self.level += 1
+        } else {
+            Js.awaitCancellablePromise {resolve, reject, onSettle =>
+                let key = self.queue.push(Pair(Js.currentTask()!, resolve))
+                onSettle {_ => self.queue.remove(key)}
+            }
+        }
+    }
+    
+    release(): Unit {
+        if(self.owner !== Js.currentTask()!) {
+            throw(GrabException)
+        } elseIf {self.level > 1} {
+            self.level -= 1
+        } else {
+            self.owner = Js.undefined()
+            self.level = 0
+            if(!self.queue.isEmpty()) {
+                let pending = self.queue.pop().grab()
+                self.owner = pending.first
+                self.level = 1
+                pending.second(Unit)
+            }
+        }
+    }
+    
+    do[T](body: () => T): T {
+        self.acquire()
+        try {
+            body()
+        } finally {
+            self.release()
+        }
+    }
+
+}
+
+extend self: LockCondition {
+
+    sleep(): Unit {
+        if(self.lock.owner !== Js.currentTask()!) {
+            throw(GrabException)
+        }
+        Js.throwIfCancelled()
+        let level = self.lock.level
+        self.lock.level = 1
+        self.lock.release()
+        try {
+            Js.awaitCancellablePromise {resolve, reject, onSettle =>
+                let key = self.queue.push(resolve)
+                onSettle {_ => self.queue.remove(key)}
+            }
+        } finally {
+            mutable error = Js.undefined()
+            mutable acquired = False
+            while {!acquired} {
+                try {
+                    self.lock.acquire()
+                    self.lock.level = level
+                    acquired = True
+                } catchAny {e =>
+                    error = e!
+                }
+            }
+            if(error.isUndefined()) {Js.throw(error)}
+        }
+    }
+
+    sleepUntil[T](body: () => Option[T]): T {
+        body().{
+            | Some(value) =>
+                value
+            | None =>
+                self.sleep()
+                tailcall self.sleepUntil(body)
+        }
+    }
+
+    wakeOne(): Unit {
+        self.queue.pop().each {resolve => resolve(Unit)}
+    }
+
+    wakeAll(): Unit {
+        self.queue.each {_, resolve => resolve(Unit)}
+        self.queue.clear()
+    }
+
+}

package/core/Log.ff

@@ -2,23 +2,34 @@ show[T: Show](value: T): Unit {
     trace(Show.show(value))
 }
 
-debugDynamic[T](value: T): Unit
-    target js sync "console.debug(value_)"
+debugDynamic[T](value: T): Unit {
+    Js->console->debug(value!)
+}
 
-debug(value: String): Unit
-    target js sync "console.debug(value_)"
+debug(value: String): Unit {
+    Js->console->debug(value)
+}
 
-verbose(value: String): Unit
-    target js sync "console.log(value_)"
+verbose(value: String): Unit {
+    Js->console->log(value)
+}
 
-info(value: String): Unit
-    target js sync "console.info(value_)"
+info(value: String): Unit {
+    Js->console->info(value)
+}
 
-warn(value: String): Unit
-    target js sync "console.warn(value_)"
+warn(value: String): Unit {
+    Js->console->warn(value)
+}
 
-error(value: String): Unit
-    target js sync "console.error(value_)"
+error(value: String): Unit {
+    Js->console->error(value)
+}
 
-trace(value: String): Unit
-    target js sync "process.stderr.write(value_ + String.fromCharCode(10))"
+trace(value: String): Unit {
+    if(Js.inBrowser()) {
+        Js->console->debug(value)
+    } else {
+        Js->process->stderr->write(value + "\n")
+    }
+}