firefly-compiler 0.4.36 → 0.4.46

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()
+            }
+        """
+
+}

package/core/NodeSystem.ff

@@ -1,189 +1,189 @@
-capability NodeSystem {}
-
-class ProcessResult(exitCode: Int, standardOut: Buffer, standardError: Buffer)
-data ProcessException(problem: String)
-
-extend self: NodeSystem {
-
-    arguments(): List[String]
-        target node async "return 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 {
-            internalAssets(self)
-        }
-    }
-
-    path(relativePath: String): Path
-        target node async """
-            import * as path from 'path'
-            return path.resolve(relativePath_)
-        """
-
-    pathFromUrl(url: String): Path
-        target node async """
-            import * as url from 'url';
-            return url.fileURLToPath(new URL(url_));
-        """
-
-    httpClient(): HttpClient
-        target js async "return null"
-
-    mainTask(): Task
-        target js async "return self_.task_"
-
-    crypto()
-        target js async "return (typeof globalThis !== 'undefined' ? globalThis : window).crypto"
-
-    js(): JsSystem
-        target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
-
-    exit[T](exitCode: Int = 0): T
-        target js async "process.exit(exitCode_)"
-
-    readStream(): Stream[Buffer]
-        target js async """
-            return ff_core_Path.internalReadStream_$(() => process.stdin)
-        """
-
-    writeBuffer(buffer: Buffer): Unit
-        target js async "process.stdout.write(new 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
-        target js async "process.stderr.write(new 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]
-        target node async """
-            const result = [];
-            for(const key in process.env) {
-                result.push(ff_core_Pair.Pair(key, process.env[key]));
-            }
-            return ff_core_List.List_toMap(result, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
-        """
-    
-    execute(
-        command: String
-        arguments: List[String]
-        standardIn: Buffer = Buffer.new(0)
-        workingDirectory: Option[Path] = None
-        environment: Option[Map[String, String]] = None
-        maxBuffer: Int = 16777216
-        killSignal: Int = 9
-    ): ProcessResult
-        target node async """
-            import * as childProcess from 'node:child_process';
-            const environment = environment_.value_ !== void 0 ? {} : process.env;
-            if(environment_.value_ !== void 0) {
-                ff_core_Map.Map_each(
-                    environment_.value_, 
-                    (k, v) => environment[k] = v, 
-                    ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String
-                );
-            }
-            const newProcess = childProcess.spawn(command_, arguments_, {
-                cwd: workingDirectory_.value_,
-                windowsHide: true,
-                signal: $task.controller.signal,
-                killSignal: killSignal_,
-                env: environment,
-            });
-            
-            let size = 0;
-            const out = [];
-            const err = [];
-            
-            newProcess.stdout.on('data', (data) => {
-                if(size > maxBuffer_) return;
-                size += data.byteLength;
-                if(size > maxBuffer_) newProcess.kill(killSignal_);
-                else out.push(data);
-            });
-
-            newProcess.stderr.on('data', (data) => {
-                if(size > maxBuffer_) return;
-                size += data.byteLength;
-                if(size > maxBuffer_) newProcess.kill(killSignal_);
-                else err.push(data);
-            });
-
-            return await new Promise((resolve, reject) => {
-                if(standardIn_.byteLength !== 0) {
-                    newProcess.stdin.write(standardIn_);
-                }
-                newProcess.stdin.end();
-                newProcess.on('error', error => {
-                    if(size > maxBuffer_) {
-                        reject(internalProcessError_("maxBuffer exceeded"));
-                    } else {
-                        reject(internalProcessError_(error.message));
-                    }
-                });
-                newProcess.on('close', code => {
-                    const o = Buffer.concat(out);
-                    const e = Buffer.concat(err);
-                    resolve(ProcessResult(
-                        code,
-                        new DataView(o.buffer, o.byteOffset, o.byteLength),
-                        new DataView(e.buffer, e.byteOffset, e.byteLength),
-                    ));
-                }); 
-            });
-        """
-
-}
-
-internalAssets(system: NodeSystem): AssetSystem
-    target node async "return system_.assets_"
-
-internalListDirectoryWithoutOpendir(system: NodeSystem, path: Path): List[Path]
-    target node async """
-        import * as fsPromises from 'fs/promises'
-        import * as path from 'path'
-        let files = await fsPromises.readdir(path_)
-        return files.map(file => path.join(path_, file))
-    """
-
-internalProcessError(problem: String): Error {
-    try {
-        throw(ProcessException(problem))
-    } catchAny {error =>
-        error
-    } grab()
-}
+capability NodeSystem {}
+
+class ProcessResult(exitCode: Int, standardOut: Buffer, standardError: Buffer)
+data ProcessException(problem: String)
+
+extend self: NodeSystem {
+
+    arguments(): List[String]
+        target node async "return 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 {
+            internalAssets(self)
+        }
+    }
+
+    path(relativePath: String): Path
+        target node async """
+            import * as path from 'path'
+            return path.resolve(relativePath_)
+        """
+
+    pathFromUrl(url: String): Path
+        target node async """
+            import * as url from 'url';
+            return url.fileURLToPath(new URL(url_));
+        """
+
+    httpClient(): HttpClient
+        target js async "return null"
+
+    mainTask(): Task
+        target js async "return self_.task_"
+
+    crypto(): Crypto
+        target js async "return (typeof globalThis !== 'undefined' ? globalThis : window).crypto"
+
+    js(): JsSystem
+        target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
+
+    exit[T](exitCode: Int = 0): T
+        target js async "process.exit(exitCode_)"
+
+    readStream(): Stream[Buffer]
+        target js async """
+            return ff_core_Path.internalReadStream_$(() => process.stdin)
+        """
+
+    writeBuffer(buffer: Buffer): Unit
+        target js async "process.stdout.write(new 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
+        target js async "process.stderr.write(new 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]
+        target node async """
+            const result = [];
+            for(const key in process.env) {
+                result.push(ff_core_Pair.Pair(key, process.env[key]));
+            }
+            return ff_core_List.List_toMap(result, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
+        """
+    
+    execute(
+        command: String
+        arguments: List[String]
+        standardIn: Buffer = Buffer.new(0)
+        workingDirectory: Option[Path] = None
+        environment: Option[Map[String, String]] = None
+        maxBuffer: Int = 16777216
+        killSignal: Int = 9
+    ): ProcessResult
+        target node async """
+            import * as childProcess from 'node:child_process';
+            const environment = environment_.value_ !== void 0 ? {} : process.env;
+            if(environment_.value_ !== void 0) {
+                ff_core_Map.Map_each(
+                    environment_.value_, 
+                    (k, v) => environment[k] = v, 
+                    ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String
+                );
+            }
+            const newProcess = childProcess.spawn(command_, arguments_, {
+                cwd: workingDirectory_.value_,
+                windowsHide: true,
+                signal: $task.controller.signal,
+                killSignal: killSignal_,
+                env: environment,
+            });
+            
+            let size = 0;
+            const out = [];
+            const err = [];
+            
+            newProcess.stdout.on('data', (data) => {
+                if(size > maxBuffer_) return;
+                size += data.byteLength;
+                if(size > maxBuffer_) newProcess.kill(killSignal_);
+                else out.push(data);
+            });
+
+            newProcess.stderr.on('data', (data) => {
+                if(size > maxBuffer_) return;
+                size += data.byteLength;
+                if(size > maxBuffer_) newProcess.kill(killSignal_);
+                else err.push(data);
+            });
+
+            return await new Promise((resolve, reject) => {
+                if(standardIn_.byteLength !== 0) {
+                    newProcess.stdin.write(standardIn_);
+                }
+                newProcess.stdin.end();
+                newProcess.on('error', error => {
+                    if(size > maxBuffer_) {
+                        reject(internalProcessError_("maxBuffer exceeded"));
+                    } else {
+                        reject(internalProcessError_(error.message));
+                    }
+                });
+                newProcess.on('close', code => {
+                    const o = Buffer.concat(out);
+                    const e = Buffer.concat(err);
+                    resolve(ProcessResult(
+                        code,
+                        new DataView(o.buffer, o.byteOffset, o.byteLength),
+                        new DataView(e.buffer, e.byteOffset, e.byteLength),
+                    ));
+                }); 
+            });
+        """
+
+}
+
+internalAssets(system: NodeSystem): AssetSystem
+    target node async "return system_.assets_"
+
+internalListDirectoryWithoutOpendir(system: NodeSystem, path: Path): List[Path]
+    target node async """
+        import * as fsPromises from 'fs/promises'
+        import * as path from 'path'
+        let files = await fsPromises.readdir(path_)
+        return files.map(file => path.join(path_, file))
+    """
+
+internalProcessError(problem: String): Error {
+    try {
+        throw(ProcessException(problem))
+    } catchAny {error =>
+        error
+    } grab()
+}