firefly-compiler 0.5.35 → 0.5.37

package/core/BuildSystem.ff

@@ -1,148 +1,156 @@
-capability BuildSystem {}
-capability BrowserCode(packageGroup: String, packageName: String, mainFile: Path, assetSystem: AssetSystem)
-capability BrowserBundle(assetSystem: AssetSystem)
-
-extend self: BuildSystem {
-
-    compileForBrowser(mainFile: String): BrowserCode {
-        // TODO: Check that the mainFile is in the current package directory
-        internalCompile(self, internalPath(self, mainFile), "browser")
-        let streams = internalListDirectory(internalPath(self, ".firefly/output/browser"))
-        let mainPackagePair = internalMainPackagePair(self)
-        BrowserCode(
-            packageGroup = mainPackagePair.first
-            packageName = mainPackagePair.second
-            mainFile = internalPath(self, mainFile)
-            assetSystem = AssetSystem(streams.toMap())
-        )
-    }
-
-    buildMode(): Bool
-        target node async "return !!self_.buildMode_"
-
-    setAssets(assetSystem: AssetSystem): Unit
-        target node async "self_.assets_ = assetSystem_"
-
-    packageAssets(): AssetSystem {
-        let streams = internalListDirectory(internalPath(self, "."))
-        AssetSystem(streams.toMap())
-    }
-
-    dependencyAssets(user: String, package: String): AssetSystem {
-        panic("dependencyAssets not yet implemented")
-    }
-
-    arguments(): List[String]
-        target node async "return self_.array_"
-
-    mainTask(): Task
-        target js async "return self_.task_"
-
-    crypto(): Crypto
-        target js async "return (typeof globalThis !== 'undefined' ? globalThis : window).crypto"
-        
-}
-
-extend self: BrowserCode {
-
-    assets(): AssetSystem {
-        self.assetSystem
-    }
-
-    bundle(minify: Bool = True, sourceMap: Bool = False): BrowserBundle {
-        let prefix = ".firefly/output/browser"
-        let mainJsBaseFile = self.mainFile.base().removeLast(".ff").grab() + ".mjs"
-        let mainJsFile = prefix + "/" + self.packageGroup + "/" + self.packageName + "/" + mainJsBaseFile
-        let mainDirectory = self.mainFile.parent().grab()
-        let file = prefix + "/Main.bundle.js"
-        internalCallEsBuild(self, mainJsFile = mainJsFile, outputPath = file, minify = minify, sourceMap = sourceMap)
-        let assets = AssetSystem([
-            Pair(file.dropFirst(prefix.size()), {mainDirectory.path(file).readStream()})
-            ...if(sourceMap) {[
-                Pair(file.dropFirst(prefix.size()) + ".map", {mainDirectory.path(file + ".map").readStream()})
-            ]} else {[]}
-        ].toMap())
-        BrowserBundle(assets)
-    }
-
-}
-
-extend self: BrowserBundle {
-
-    assets(): AssetSystem {
-        self.assetSystem
-    }
-
-}
-
-
-internalCallEsBuild(
-    self: BrowserCode
-    mainJsFile: String
-    outputPath: String
-    minify: Bool
-    sourceMap: Bool
-): Unit
-    target node async """
-        import * as esbuild from 'esbuild'
-        return await esbuild.build({
-            stdin: {contents: `import {$run$} from './${mainJsFile_}';`, resolveDir: '.'},
-            bundle: true,
-            minify: minify_,
-            sourcemap: sourceMap_,
-            platform: 'browser',
-            target: 'es2017',
-            external: ['../../../node_modules/*'], // TODO
-            outfile: outputPath_
-        })
-    """
-
-internalNodeCallEsBuild(
-    self: NodeSystem
-    mainJsFile: String
-    outputPath: String
-    minify: Bool
-): Unit
-    target node async """
-        import * as esbuild from 'esbuild'
-        return await esbuild.build({
-            entryPoints: [mainJsFile_],
-            bundle: true,
-            minify: minify_,
-            sourcemap: true,
-            platform: 'node',
-            target: 'es6',
-            external: ['../../../node_modules/*'], // TODO
-            outfile: outputPath_
-        })
-    """
-
-internalListDirectory(path: Path): List[Pair[String, () => Stream[Buffer]]] {
-    function go(currentPath: Path): Stream[Path] {
-        currentPath.entries().flatMap {file =>
-            if(file.isDirectory()) {
-                go(file.path())
-            } else {
-                [file.path()].toStream()
-            }
-        }
-    }
-    go(path).map {file =>
-        Pair("/" + file.relativeTo(path).replace("\\", "/"), {file.readStream()})
-    }.toList()
-}
-
-internalPath(buildSystem: BuildSystem, absoluteOrRelative: String): Path
-    target node async """
-        return absoluteOrRelative_
-    """
-
-internalCompile(buildSystem: BuildSystem, mainFile: Path, target: String): Unit
-    target node async """
-        return await $firefly_compiler.buildViaBuildSystem_$(buildSystem_, buildSystem_.fireflyPath_, mainFile_, target_, $task)
-    """
-
-internalMainPackagePair(buildSystem: BuildSystem): Pair[String, String]
-    target node async """
-        return {first_: buildSystem_.mainPackagePair_.group_, second_: buildSystem_.mainPackagePair_.name_}
-    """
+capability BuildSystem {}
+capability BrowserCode(packageGroup: String, packageName: String, mainFile: Path, assetSystem: AssetSystem)
+capability BrowserBundle(assetSystem: AssetSystem)
+
+extend self: BuildSystem {
+
+    compileForBrowser(mainFile: String): BrowserCode {
+        // TODO: Check that the mainFile is in the current package directory
+        internalCompile(self, internalPath(self, mainFile), "browser")
+        let streams = internalListDirectory(internalPath(self, ".firefly/output/browser"))
+        let mainPackagePair = internalMainPackagePair(self)
+        BrowserCode(
+            packageGroup = mainPackagePair.first
+            packageName = mainPackagePair.second
+            mainFile = internalPath(self, mainFile)
+            assetSystem = AssetSystem(streams.toMap())
+        )
+    }
+
+    buildMode(): Bool {
+        !!self!->"buildMode_"?
+    }
+    
+    setAssets(assetSystem: AssetSystem): Unit {
+        self!->"assets_" = assetSystem!
+    }
+
+    packageAssets(): AssetSystem {
+        let streams = internalListDirectory(internalPath(self, "."))
+        AssetSystem(streams.toMap())
+    }
+
+    dependencyAssets(user: String, package: String): AssetSystem {
+        panic("dependencyAssets not yet implemented")
+    }
+
+    arguments(): List[String] {
+        self!->"array_"?
+    }
+
+    mainTask(): Task {
+        self!->"task_"?
+    }
+
+    crypto(): Crypto {
+        Js->crypto?
+    }
+        
+}
+
+extend self: BrowserCode {
+
+    assets(): AssetSystem {
+        self.assetSystem
+    }
+
+    bundle(minify: Bool = True, sourceMap: Bool = False): BrowserBundle {
+        let prefix = ".firefly/output/browser"
+        let mainJsBaseFile = self.mainFile.base().removeLast(".ff").grab() + ".mjs"
+        let mainJsFile = prefix + "/" + self.packageGroup + "/" + self.packageName + "/" + mainJsBaseFile
+        let mainDirectory = self.mainFile.parent().grab()
+        let file = prefix + "/Main.bundle.js"
+        internalCallEsBuild(self, mainJsFile = mainJsFile, outputPath = file, minify = minify, sourceMap = sourceMap)
+        let assets = AssetSystem([
+            Pair(file.dropFirst(prefix.size()), {mainDirectory.path(file).readStream()})
+            ...if(sourceMap) {[
+                Pair(file.dropFirst(prefix.size()) + ".map", {mainDirectory.path(file + ".map").readStream()})
+            ]} else {[]}
+        ].toMap())
+        BrowserBundle(assets)
+    }
+
+}
+
+extend self: BrowserBundle {
+
+    assets(): AssetSystem {
+        self.assetSystem
+    }
+
+}
+
+
+internalCallEsBuild(
+    self: BrowserCode
+    mainJsFile: String
+    outputPath: String
+    minify: Bool
+    sourceMap: Bool
+): Unit {
+    let esbuild = Js.import("esbuild")
+    esbuild->build(Js->(
+        stdin = Js->(contents = "import {$run$} from './" + mainJsFile + "';", resolveDir = ".")
+        bundle = True
+        minify = minify
+        sourcemap = sourceMap
+        platform = "browser"
+        target = "es2017"
+        external = ["../../../node_modules/*"] // TODO
+        outfile = outputPath
+    ))
+}
+
+internalNodeCallEsBuild(
+    self: NodeSystem
+    mainJsFile: String
+    outputPath: String
+    minify: Bool
+): Unit {
+    let esbuild = Js.import("esbuild")
+    esbuild->build(Js->(
+        entryPoints = [mainJsFile]
+        bundle = True
+        minify = minify
+        sourcemap = True
+        platform = "node"
+        target = "es2017"
+        external = ["../../../node_modules/*"] // TODO
+        outfile = outputPath
+    ))
+}
+
+internalListDirectory(path: Path): List[Pair[String, () => Stream[Buffer]]] {
+    function go(currentPath: Path): Stream[Path] {
+        currentPath.entries().flatMap {file =>
+            if(file.isDirectory()) {
+                go(file.path())
+            } else {
+                [file.path()].toStream()
+            }
+        }
+    }
+    go(path).map {file =>
+        Pair("/" + file.relativeTo(path).replace("\\", "/"), {file.readStream()})
+    }.toList()
+}
+
+internalPath(buildSystem: BuildSystem, absoluteOrRelative: String): Path {
+    let nodePath = Js.import("path")
+    Path(nodePath->resolve(absoluteOrRelative)?)
+}
+
+internalCompile(buildSystem: BuildSystem, mainFile: Path, target: String): Unit {
+    // Ported from the old FFI. It's quite fragile w.r.t. changes in code generation.
+    Js.await(Js.rawIdentifier("$firefly_compiler")->"buildViaBuildSystem_$"(
+        buildSystem! 
+        internalPath(buildSystem, buildSystem!->"fireflyPath_"?)!
+        mainFile.base()
+        target
+        Js.currentTask()!
+    ))
+}
+
+internalMainPackagePair(buildSystem: BuildSystem): Pair[String, String] {
+    Pair(buildSystem!->"mainPackagePair_"->"group_"?, buildSystem!->"mainPackagePair_"->"name_"?)
+}

package/core/Channel.ff

@@ -1,4 +1,9 @@
-capability Channel[T] {}
+capability Channel[T](
+    capacity: Int
+    buffer: Array[T]
+    readers: JsValue
+    writers: JsValue
+)
 
 extend self[T]: Channel[T] {
 
@@ -13,15 +18,22 @@ extend self[T]: Channel[T] {
 }
 
 
-capability ChannelAction[T] {}
+capability ChannelAction[T](
+    channel: Channel[JsValue]
+    body: JsValue
+    message: Option[JsValue]
+    previous: Option[ChannelAction[T]]
+)
 
 extend self[T]: ChannelAction[T] {
+    
+    readOr[M](channel: Channel[M], body: M => T): ChannelAction[T] {
+        ChannelAction(channel!?, body!, None, Some(self))
+    }
 
-    readOr[M](channel: Channel[M], body: M => T): ChannelAction[T]
-        target js async "return {channel: channel_, body: body_, previous: self_}"
-
-    writeOr[M](channel: Channel[M], message: M, body: () => T): ChannelAction[T]
-        target js async "return {channel: channel_, body: body_, message: message_, previous: self_}"
+    writeOr[M](channel: Channel[M], message: M, body: () => T): ChannelAction[T] {
+        ChannelAction(channel!?, body!, Some(message!), Some(self))
+    }
 
     wait(): T {
         internalRunChannelAction(self, None)
@@ -37,95 +49,86 @@ extend self[T]: ChannelAction[T] {
 
 }
 
-readOr[M, T](channel: Channel[M], body: M => T): ChannelAction[T]
-    target js async "return {channel: channel_, body: body_, previous: null}"
-
-writeOr[M, T](channel: Channel[M], message: M, body: () => T): ChannelAction[T]
-    target js async "return {channel: channel_, body: body_, message: message_, previous: null}"
-
-
-internalRunChannelAction[T](action: ChannelAction[T], mode: Option[Pair[() => T, Option[Duration]]]): T
-    target js async """
-        ff_core_Task.Task_throwIfAborted($task)
+readOr[M, T](channel: Channel[M], body: M => T): ChannelAction[T] {
+    ChannelAction(channel!?, body!, None, None)
+}
 
-        // Convert the linked actions into an array.
-        let actions = []
-        while(action_ != null) {
-            actions.push(action_)
-            action_ = action_.previous
-        }
-        actions.reverse()
+writeOr[M, T](channel: Channel[M], message: M, body: () => T): ChannelAction[T] {
+    ChannelAction(channel!?, body!, Some(message!), None)
+}
 
-        // If any reads or writes can be done immediately, do the first one and return.
-        for(let action of actions) {
-            if(action.hasOwnProperty("message")) {
-                if(action.channel.readers.size != 0) {
-                    let reader = action.channel.readers.values().next().value
-                    action.channel.readers.delete(reader)
-                    reader.resolve(action.message)
-                    return await action.body($task)
-                } else if(action.channel.buffer.length < action.channel.capacity) {
-                    action.channel.buffer.push(action.message)
-                    return await action.body($task)
-                }
-            } else {
-                if(action.channel.buffer.length != 0) {
-                    return await action.body(action.channel.buffer.shift(), $task)
-                } else if(action.channel.writers.size != 0) {
-                    let writer = action.channel.writers.values().next().value
-                    action.channel.writers.delete(writer)
-                    writer.resolve()
-                    return await action.body(writer.message, $task)
-                }
-            }
+internalRunChannelAction[T](action: ChannelAction[T], mode: Option[Pair[() => T, Option[Duration]]]): T {
+    Js.throwIfCancelled()
+    
+    // Convert the linked actions into an array.
+    let actions = [].toArray()
+    function findActions(action: ChannelAction[T]) {
+        actions.push(action)
+        action.previous.each {findActions(_)}
+    }
+    findActions(action)
+    
+    // If any reads or writes can be done immediately, do the first one and return.
+    mutable foundPromise = None
+    actions.eachWhile {action =>
+        action.message.{
+            | Some(message) {action.channel.readers->size !== 0} => 
+                let reader = action.channel.readers->values()->next()->value
+                action.channel.readers->delete(reader)
+                reader->resolve(message)
+                foundPromise = Some(action.body.callValue1(Js.currentTask()!))
+            | Some(message) {action.channel.buffer.size() < action.channel.capacity} =>
+                action.channel.buffer.push(message)
+                foundPromise = Some(action.body.callValue1(Js.currentTask()!))
+            | Some(_) =>
+            | None {action.channel.buffer.size() != 0} => 
+                action.channel.buffer.reverse()
+                let message = action.channel.buffer.pop()
+                action.channel.buffer.reverse()
+                foundPromise = Some(action.body.callValue2(message!, Js.currentTask()!))
+            | None {action.channel.writers->size !== 0} => 
+                let writer = action.channel.writers->values()->next()->value
+                action.channel.writers->delete(writer)
+                writer->resolve()
+                foundPromise = Some(action.body.callValue2(writer->message!, Js.currentTask()!))
+            | None => 
         }
-
-        // If there's an "immediately(body)" action, do that now.
-        if(mode_.value_ && mode_.value_.second_.value_ == null) return await mode_.value_.first_($task)
-
-        // Otherwise, start waiting for one of the readers or writers (or timeout(body), or cancellation) to happen.
-        let abort = null
-        let finish = null
-        let cleanups = []
-        function doCleanup() {
-            for(let cleanup of cleanups) cleanup()
+        foundPromise.isEmpty()
+    }
+    foundPromise.map {Js.await(_)?}.else:
+    
+    // If there's an "immediately(body)" action, do that now.
+    if(mode.any {_.second.isEmpty()}) {
+        let makePromise = mode.grab().first
+        Js.await(makePromise()!)?
+    } else:
+    
+    // Otherwise, start waiting for one of the readers or writers (or timeout(body), or cancellation) to happen.
+    let body = Js.awaitCancellablePromise {resolve, reject, onSettled =>
+        mode.each {m =>
+            let timeout = Js->setTimeout(Js->{resolve(m.first)}, m.second.grab().seconds * 1000.0)
+            onSettled {_ => Js->clearTimeout(timeout)}
         }
-        let promise = new Promise((resolve, reject) => {
-            if(mode_.value_) finish = () => {doCleanup(); resolve(() => mode_.value_.first_($task))}
-            abort = () => {doCleanup(); reject($task.controller.signal.reason)}
-            for(let action of actions) {
-                if(action.hasOwnProperty("message")) {
-                    let writer = {
-                        resolve: () => {
-                            doCleanup()
-                            resolve(() => action.body($task))
-                        },
-                        message: action.message
-                    }
-                    cleanups.push(() => action.channel.writers.delete(writer))
-                    action.channel.writers.add(writer)
-                } else {
-                    let reader = {
-                        resolve: m => {
-                            doCleanup()
-                            resolve(() => action.body(m, $task))
+        actions.each {action =>
+            action.message.{
+                | Some(message) => 
+                    let writer = Js->(
+                        resolve = Js->{resolve({action.body.callValue1(Js.currentTask()!)?})}
+                        message = message
+                    )
+                    action.channel.writers->add(writer)
+                    onSettled {_ => action.channel.writers->delete(writer)}
+                | None =>
+                    let reader = Js->(
+                        resolve = Js->{m =>
+                            resolve({action.body.callValue2(m, Js.currentTask()!)?})
                         }
-                    }
-                    cleanups.push(() => action.channel.readers.delete(reader))
-                    action.channel.readers.add(reader)
-                }
+                    )
+                    action.channel.readers->add(reader)
+                    onSettled {_ => action.channel.readers->delete(reader)}
             }
-        })
-        let timeout = null
-        try {
-            $task.controller.signal.addEventListener('abort', abort)
-            if(finish != null) timeout = setTimeout(finish, mode_.value_.second_.value_ * 1000)
-            let body = await promise
-            if(timeout != null) { clearTimeout(timeout); timeout = null }
-            return await body()
-        } finally {
-            if(timeout != null) clearTimeout(timeout)
-            $task.controller.signal.removeEventListener('abort', abort)
-            if($task.controller.signal.aborted) $task.controller = new AbortController()
         }
-    """
+    }
+    body()
+    
+}

package/core/Char.ff

@@ -12,7 +12,8 @@ extend self: Char {
 
     isAsciiDigit(): Bool {self >= '0' && self <= '9'}
 
-    toString(): String
-        target js sync "return String.fromCharCode(self_)"
+    toString(): String {
+        Js->String->fromCharCode(self)?
+    }
 
 }

package/core/Core.ff

@@ -29,34 +29,27 @@ do[T](body: () => T): T {
     body()
 }
 
-try[T](body: () => T): Try[T]
-    target js sync """
-        try {
-            return {Success: true, value_: body_()}
-        } catch(e) {
-            return {Failure: true, error_: e}
-        }
-    """
-    target js async """
-        try {
-            return {Success: true, value_: await body_($task)}
-        } catch(e) {
-            return {Failure: true, error_: e}
-        }
-    """
+try[T](body: () => T): Try[T] {
+    // Special cased by the compiler
+    try {
+        Success(body())
+    } catchAny {e =>
+        Failure(e)
+    }
+}
 
 throw[E: HasAnyTag, T](exception: E): T {
     throwAny(Any.toAny(exception))
 }
 
-throwAny[T](exception: Any): T
-    target js sync "throw Object.assign(new Error(), {ffException: exception_})"
-
-panic[T](message: String): T
-    target js sync "throw new Error(message_)"
+throwAny[T](exception: Any): T {
+    let e = Js->Error->()
+    e->ffException = exception!
+    Js.throw(e)
+}
 
+panic[T](message: String): T {
+    Js.throw(Js->Error->(message))
+}
 
-same[T](x: T, y: T): Bool
-    target js sync """return x_ === y_"""
-    
 data GrabException()