firefly-compiler 0.5.39 → 0.5.40

package/core/Lock.ff

@@ -1,108 +1,108 @@
-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()
-    }
-
-}
+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/NodeSystem.ff

@@ -1,198 +1,198 @@
-capability NodeSystem {}
-
-class ProcessResult(exitCode: Int, standardOut: Buffer, standardError: Buffer)
-data ProcessException(problem: String)
-
-extend self: NodeSystem {
-
-    arguments(): List[String] {
-        self!->"array_"?
-    }
-
-    assets(): AssetSystem {
-        let assetPkgSnapshotPath = self.path("/snapshot/output/assets")
-        if(assetPkgSnapshotPath.isDirectory()) {
-            // Opendir gives ENOENT: no such file or directory, opendir '/snapshot/output/assets'
-            function streams(path: Path): Stream[Pair[String, () => Stream[Buffer]]] {
-                internalListDirectoryWithoutOpendir(self, path).toStream().flatMap {file =>
-                    if(file.isDirectory()) {
-                        streams(file)
-                    } else {
-                        [Pair("/" + file.relativeTo(assetPkgSnapshotPath), {file.readStream()})].toStream()
-                    }
-                }
-            }
-            AssetSystem(streams(assetPkgSnapshotPath).toMap())
-        } else {
-            self!->"assets_"?
-        }
-    }
-
-    path(relativePath: String): Path {
-        let nodePath = Js.import("path")
-        Path(nodePath->resolve(relativePath)?)
-    }
-
-    pathFromUrl(url: String): Path {
-        let nodeUrl = Js.import("url")
-        Path(nodeUrl->fileURLToPath(Js->URL->(url))?)
-    }
-
-    httpClient(): HttpClient {
-        Js.globalThis()?
-    }
-
-    mainTask(): Task {
-        self!->"task_"?
-    }
-
-    crypto(): Crypto {
-        Js.globalThis()->crypto?
-    }
-
-    js(): JsSystem {
-        Js.jsSystem()
-    }
-
-    exit[T](exitCode: Int = 0): T {
-        Js->process->exit(exitCode)?
-    }
-
-    readStream(): Stream[Buffer] {
-        Path.internalReadStream {Js->process->stdin}
-    }
-
-    writeBuffer(buffer: Buffer): Unit {
-        Js->process->stdout->write(Js->Uint8Array->(buffer!->buffer, buffer!->byteOffset, buffer!->byteLength))
-    }
-
-    writeStream(stream: Stream[Buffer]): Unit {
-        stream.each {self.writeBuffer(_)}
-    }
-
-    writeText(text: String): Unit {
-        self.writeBuffer(text.toBuffer())
-    }
-
-    writeLine(text: String): Unit {
-        self.writeText(text + "\n")
-    }
-
-    writeErrorBuffer(buffer: Buffer): Unit {
-        Js->process->stderr->write(Js->Uint8Array->(buffer!->buffer, buffer!->byteOffset, buffer!->byteLength))
-    }
-
-    writeErrorStream(stream: Stream[Buffer]): Unit {
-        stream.each {self.writeErrorBuffer(_)}
-    }
-
-    writeErrorText(text: String): Unit {
-        self.writeErrorBuffer(text.toBuffer())
-    }
-
-    writeErrorLine(text: String): Unit {
-        self.writeErrorText(text + "\n")
-    }
-    
-    environment(): Map[String, String] {
-        mutable result = Map.new()
-        Js->process->env.each {key =>
-            result = result.add(key?, Js->process->env.get(key)?)
-        }
-        result
-    }
-
-    execute(
-        command: String
-        arguments: List[String]
-        standardIn: Buffer = Buffer.new(0)
-        directory: Option[Path] = None
-        environment: Option[Map[String, String]] = None
-        maxBuffer: Int = 16777216
-        killSignal: Int = 9
-        shell: Bool = False
-    ): ProcessResult {
-        let childProcess = Js.import("node:child_process")
-        let env = environment.map {e =>
-            let o = Js.object()
-            e.each {k, v => o.set(k, v)}
-            o
-        }.else {Js->process->env}
-        Js.withSignal {signal => Js.awaitCancellablePromise {resolve, reject, onSettle =>
-            let newProcess = childProcess->spawn(command, arguments, Js->(
-                cwd = directory.map {_.absolutePath!}.else {Js.undefined()}
-                windowsHide = True
-                signal = signal
-                killSignal = killSignal
-                env = env
-                shell = shell
-            ))
-            mutable size = 0
-            let out = Array.new()
-            let err = Array.new()
-            newProcess->stdout->on("data", Js->{data =>
-                if(size <= maxBuffer) {
-                    size += data->byteLength?
-                    if(size > maxBuffer) {
-                        newProcess->kill(killSignal)
-                    } else {
-                        out.push(data)
-                    }
-                }
-                Unit
-            })
-            newProcess->stderr->on("data", Js->{data =>
-                if(size <= maxBuffer) {
-                    size += data->byteLength?
-                    if(size > maxBuffer) {
-                        newProcess->kill(killSignal)
-                    } else {
-                        err.push(data)
-                    }
-                }
-                Unit
-            })
-            if(standardIn!->byteLength !== 0) {
-                newProcess->stdin->write(standardIn!)
-            }
-            newProcess->stdin->end()
-            newProcess->on("error", Js->{error =>
-                if(size > maxBuffer) {
-                    reject(internalProcessError("maxBuffer exceeded"))
-                } else {
-                    reject(internalProcessError(error->message?))
-                }
-            })
-            newProcess->on("close", Js->{code =>
-                let o = Js->Buffer->concat(out.drain()!)
-                let e = Js->Buffer->concat(err.drain()!)
-                resolve(ProcessResult(
-                    code?
-                    Js->DataView->(o->buffer, o->byteOffset, o->byteLength)?
-                    Js->DataView->(e->buffer, e->byteOffset, e->byteLength)?
-                ))
-            })
-            onSettle {fulfilled =>
-                if(!fulfilled) {
-                    newProcess->kill(killSignal)
-                }
-            }
-        }}
-    }
-
-}
-
-internalListDirectoryWithoutOpendir(system: NodeSystem, path: Path): List[Path] {
-    let fsPromises = Js.import("fs/promises")
-    let nodePath = Js.import("path")
-    let files = Js.await(fsPromises->readdir(path.absolutePath))
-    files.grabArray().map {file => Path(nodePath->join(path.absolutePath, file)?)}
-}
-
-internalProcessError(problem: String): Error {
-    try {
-        throw(ProcessException(problem))
-    } catchAny {error =>
-        error
-    }
-}
+capability NodeSystem {}
+
+class ProcessResult(exitCode: Int, standardOut: Buffer, standardError: Buffer)
+data ProcessException(problem: String)
+
+extend self: NodeSystem {
+
+    arguments(): List[String] {
+        self!->"array_"?
+    }
+
+    assets(): AssetSystem {
+        let assetPkgSnapshotPath = self.path("/snapshot/output/assets")
+        if(assetPkgSnapshotPath.isDirectory()) {
+            // Opendir gives ENOENT: no such file or directory, opendir '/snapshot/output/assets'
+            function streams(path: Path): Stream[Pair[String, () => Stream[Buffer]]] {
+                internalListDirectoryWithoutOpendir(self, path).toStream().flatMap {file =>
+                    if(file.isDirectory()) {
+                        streams(file)
+                    } else {
+                        [Pair("/" + file.relativeTo(assetPkgSnapshotPath), {file.readStream()})].toStream()
+                    }
+                }
+            }
+            AssetSystem(streams(assetPkgSnapshotPath).toMap())
+        } else {
+            self!->"assets_"?
+        }
+    }
+
+    path(relativePath: String): Path {
+        let nodePath = Js.import("path")
+        Path(nodePath->resolve(relativePath)?)
+    }
+
+    pathFromUrl(url: String): Path {
+        let nodeUrl = Js.import("url")
+        Path(nodeUrl->fileURLToPath(Js->URL->(url))?)
+    }
+
+    httpClient(): HttpClient {
+        Js.globalThis()?
+    }
+
+    mainTask(): Task {
+        self!->"task_"?
+    }
+
+    crypto(): Crypto {
+        Js.globalThis()->crypto?
+    }
+
+    js(): JsSystem {
+        Js.jsSystem()
+    }
+
+    exit[T](exitCode: Int = 0): T {
+        Js->process->exit(exitCode)?
+    }
+
+    readStream(): Stream[Buffer] {
+        Path.internalReadStream {Js->process->stdin}
+    }
+
+    writeBuffer(buffer: Buffer): Unit {
+        Js->process->stdout->write(Js->Uint8Array->(buffer!->buffer, buffer!->byteOffset, buffer!->byteLength))
+    }
+
+    writeStream(stream: Stream[Buffer]): Unit {
+        stream.each {self.writeBuffer(_)}
+    }
+
+    writeText(text: String): Unit {
+        self.writeBuffer(text.toBuffer())
+    }
+
+    writeLine(text: String): Unit {
+        self.writeText(text + "\n")
+    }
+
+    writeErrorBuffer(buffer: Buffer): Unit {
+        Js->process->stderr->write(Js->Uint8Array->(buffer!->buffer, buffer!->byteOffset, buffer!->byteLength))
+    }
+
+    writeErrorStream(stream: Stream[Buffer]): Unit {
+        stream.each {self.writeErrorBuffer(_)}
+    }
+
+    writeErrorText(text: String): Unit {
+        self.writeErrorBuffer(text.toBuffer())
+    }
+
+    writeErrorLine(text: String): Unit {
+        self.writeErrorText(text + "\n")
+    }
+    
+    environment(): Map[String, String] {
+        mutable result = Map.new()
+        Js->process->env.each {key =>
+            result = result.add(key?, Js->process->env.get(key)?)
+        }
+        result
+    }
+
+    execute(
+        command: String
+        arguments: List[String]
+        standardIn: Buffer = Buffer.new(0)
+        directory: Option[Path] = None
+        environment: Option[Map[String, String]] = None
+        maxBuffer: Int = 16777216
+        killSignal: Int = 9
+        shell: Bool = False
+    ): ProcessResult {
+        let childProcess = Js.import("node:child_process")
+        let env = environment.map {e =>
+            let o = Js.object()
+            e.each {k, v => o.set(k, v)}
+            o
+        }.else {Js->process->env}
+        Js.withSignal {signal => Js.awaitCancellablePromise {resolve, reject, onSettle =>
+            let newProcess = childProcess->spawn(command, arguments, Js->(
+                cwd = directory.map {_.absolutePath!}.else {Js.undefined()}
+                windowsHide = True
+                signal = signal
+                killSignal = killSignal
+                env = env
+                shell = shell
+            ))
+            mutable size = 0
+            let out = Array.new()
+            let err = Array.new()
+            newProcess->stdout->on("data", Js->{data =>
+                if(size <= maxBuffer) {
+                    size += data->byteLength?
+                    if(size > maxBuffer) {
+                        newProcess->kill(killSignal)
+                    } else {
+                        out.push(data)
+                    }
+                }
+                Unit
+            })
+            newProcess->stderr->on("data", Js->{data =>
+                if(size <= maxBuffer) {
+                    size += data->byteLength?
+                    if(size > maxBuffer) {
+                        newProcess->kill(killSignal)
+                    } else {
+                        err.push(data)
+                    }
+                }
+                Unit
+            })
+            if(standardIn!->byteLength !== 0) {
+                newProcess->stdin->write(standardIn!)
+            }
+            newProcess->stdin->end()
+            newProcess->on("error", Js->{error =>
+                if(size > maxBuffer) {
+                    reject(internalProcessError("maxBuffer exceeded"))
+                } else {
+                    reject(internalProcessError(error->message?))
+                }
+            })
+            newProcess->on("close", Js->{code =>
+                let o = Js->Buffer->concat(out.drain()!)
+                let e = Js->Buffer->concat(err.drain()!)
+                resolve(ProcessResult(
+                    code?
+                    Js->DataView->(o->buffer, o->byteOffset, o->byteLength)?
+                    Js->DataView->(e->buffer, e->byteOffset, e->byteLength)?
+                ))
+            })
+            onSettle {fulfilled =>
+                if(!fulfilled) {
+                    newProcess->kill(killSignal)
+                }
+            }
+        }}
+    }
+
+}
+
+internalListDirectoryWithoutOpendir(system: NodeSystem, path: Path): List[Path] {
+    let fsPromises = Js.import("fs/promises")
+    let nodePath = Js.import("path")
+    let files = Js.await(fsPromises->readdir(path.absolutePath))
+    files.grabArray().map {file => Path(nodePath->join(path.absolutePath, file)?)}
+}
+
+internalProcessError(problem: String): Error {
+    try {
+        throw(ProcessException(problem))
+    } catchAny {error =>
+        error
+    }
+}