firefly-compiler 0.4.51 → 0.4.52

package/core/Lock.ff

@@ -1,144 +1,144 @@
-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()
-        } grab()
-    }
-
-}
-
-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 {}
+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()
+        } grab()
+    }
+
+}
+
+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()
+            }
+        """
+
+}