firefly-compiler 0.4.4

package/core/BuildSystem.ff

@@ -0,0 +1,144 @@
+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(): Array[String]
+        target node async "return self_.array_"
+
+    mainTask(): Task
+        target js async "return self_.task_"
+
+}
+
+extend self: BrowserCode {
+
+    assets(): AssetSystem {
+        self.assetSystem
+    }
+
+    bundle(minify: Bool = True, sourceMap: Bool = False): BrowserBundle {
+        let prefix = ".firefly/output/browser"
+        let mainJsBaseFile = self.mainFile.absolute().removeLast(".ff").grab() + ".mjs"
+        let mainJsFile = prefix + "/" + self.packageGroup + "/" + self.packageName + "/" + mainJsBaseFile
+        let file = prefix + "/Main.bundle.js"
+        internalCallEsBuild(self, mainJsFile = mainJsFile, outputPath = file, minify = minify, sourceMap = sourceMap)
+        let assets = AssetSystem([
+            Pair(file.dropFirst(prefix.size()), {self.mainFile.path(file).readStream()})
+            ...if(sourceMap) {[
+                Pair(file.dropFirst(prefix.size()) + ".map", {self.mainFile.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({
+            entryPoints: [mainJsFile_],
+            bundle: true,
+            minify: minify_,
+            sourcemap: sourceMap_,
+            platform: 'browser',
+            target: 'es6',
+            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), {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_}
+    """

package/core/Channel.ff

@@ -0,0 +1,131 @@
+capability Channel[T] {}
+
+extend self[T]: Channel[T] {
+
+    read(): T {
+        readOr(self, {_}).wait()
+    }
+
+    write(message: T): Unit {
+        writeOr(self, message, {}).wait()
+    }
+
+}
+
+
+capability ChannelAction[T] {}
+
+extend self[T]: ChannelAction[T] {
+
+    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_}"
+
+    wait(): T {
+        internalRunChannelAction(self, None)
+    }
+
+    timeout(duration: Duration, body: () => T): T {
+        internalRunChannelAction(self, Some(Pair(body, Some(duration))))
+    }
+
+    immediately(body: () => T): T {
+        internalRunChannelAction(self, Some(Pair(body, None)))
+    }
+
+}
+
+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)
+
+        // Convert the linked actions into an array.
+        let actions = []
+        while(action_ != null) {
+            actions.push(action_)
+            action_ = action_.previous
+        }
+        actions.reverse()
+
+        // 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)
+                }
+            }
+        }
+
+        // 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()
+        }
+        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))
+                        }
+                    }
+                    cleanups.push(() => action.channel.readers.delete(reader))
+                    action.channel.readers.add(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()
+        }
+    """

package/core/Char.ff

@@ -0,0 +1,18 @@
+newtype Char(codeUnit: Int)
+
+extend self: Char {
+
+    isAsciiLetter(): Bool {self.isAsciiUpper() || self.isAsciiLower()}
+
+    isAsciiLetterOrDigit(): Bool {self.isAsciiLetter() || self.isAsciiDigit()}
+
+    isAsciiUpper(): Bool {self >= 'A' && self <= 'Z'}
+
+    isAsciiLower(): Bool {self >= 'a' && self <= 'z'}
+
+    isAsciiDigit(): Bool {self >= '0' && self <= '9'}
+
+    toString(): String
+        target js sync "return String.fromCharCode(self_)"
+
+}

package/core/Core.ff

@@ -0,0 +1,58 @@
+if[T](condition: Bool, body: () => T): Option[T] {
+    condition.{
+        | False => None
+        | True => Some(body())
+    }
+}
+
+while(condition: () => Bool, body: () => Unit): Unit {
+    condition().{
+        | False =>
+        | True =>
+            body()
+            tailcall while(condition, body)
+    }
+}
+
+doWhile(body: () => Bool): Unit {
+    while {body()} {}
+}
+
+doUntil[T](body: () => Option[T]): T {
+    body().{
+        | Some(v) => v
+        | None => tailcall doUntil(body)
+    }
+}
+
+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}
+        }
+    """
+
+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_)"
+
+data GrabException()

package/core/Duration.ff

@@ -0,0 +1,15 @@
+newtype Duration(seconds: Float)
+
+extend self: Duration {
+
+    show(digits: Int = 3): String {
+        self.seconds.toFixed(digits) + " s"
+    }
+
+}
+
+instance Duration: Show {
+    show(value: Duration): String {
+        value.show()
+    }
+}

package/core/Equal.ff

@@ -0,0 +1,52 @@
+trait T: Equal {
+    equals(x: T, y: T): Bool
+}
+
+notEquals[T: Equal](x: T, y: T): Bool {
+    !equals(x, y)
+}
+
+instance Nothing: Equal {
+    equals(x: Nothing, y: Nothing): Bool {True}
+}
+
+instance Bool: Equal {
+    equals(x: Bool, y: Bool): Bool
+        target js sync """return x_ === y_"""
+}
+
+instance Char: Equal {
+    equals(x: Char, y: Char): Bool
+        target js sync """return x_ === y_"""
+}
+
+instance Int: Equal {
+    equals(x: Int, y: Int): Bool
+        target js sync """return x_ === y_"""
+}
+
+instance Float: Equal {
+    equals(x: Float, y: Float): Bool
+        target js sync """return x_ === y_"""
+}
+
+instance String: Equal {
+    equals(x: String, y: String): Bool
+        target js sync """return x_ === y_"""
+}
+
+instance List[T]: Equal {
+    equals(x: List[T], y: List[T]): Bool
+        target js sync """
+            let a = x_
+            let b = y_
+            if(a === b) return true
+            while(a.Link && b.Link) {
+                if(a === b) return true
+                if(!ff_core_Equal_Equal$T.equals_(a.head_, b.head_)) return false
+                a = a.tail_
+                b = b.tail_
+            }
+            return a.Empty && b.Empty
+        """
+}

package/core/Error.ff

@@ -0,0 +1,20 @@
+data Error {}
+
+extend self: Error {
+
+    rethrow[T](): T
+        target js sync "throw self_"
+
+    name(): String
+        target js sync "return self_.name || ''"
+
+    message(): String
+        target js sync "return self_.message || ''"
+
+    stack(): String
+        target js sync "return self_.stack || ''"
+
+    exception(): Option[Any]
+        target js sync "return self_.ffException ? ff_core_Option.Some(self_.ffException) : ff_core_Option.None()"
+
+}

package/core/FileHandle.ff

@@ -0,0 +1,41 @@
+capability FileHandle {}
+
+extend self: FileHandle {
+
+    close(): Unit
+        target js async """
+            await self_.close()
+        """
+
+    read(buffer: Buffer, offset: Int = 0, length: Option[Int] = None, position: Option[Int] = None): Unit
+        target js async """
+            ff_core_Task.Task_throwIfAborted($task)
+            await self_.read(buffer_, {offset: offset_, length: length.value_, position: position.value_})
+        """
+
+    write(buffer: Buffer, offset: Int = 0, length: Option[Int] = None, position: Option[Int] = None): Unit
+        target js async """
+            ff_core_Task.Task_throwIfAborted($task)
+            await self_.write(buffer_, offset_, length.value_, position.value_)
+        """
+
+    writeText(text: String, position: Option[Int] = None, encoding: String = "utf8"): Unit
+        target js async """
+            ff_core_Task.Task_throwIfAborted($task)
+            await self_.write(text, position.value_, encoding_)
+        """
+        
+    truncate(length: Int = 0): Unit
+        target js async """
+            ff_core_Task.Task_throwIfAborted($task)
+            await self_.truncate(length_)
+        """
+
+    sync(dataOnly: Bool = False): Unit
+        target js async """
+            ff_core_Task.Task_throwIfAborted($task)
+            if(dataOnly_) await self_.datasync()
+            else await self_.sync()
+        """
+
+}

package/core/Float.ff

@@ -0,0 +1,41 @@
+data Float {}
+
+extend self: Float {
+
+    toInt(): Int
+        target js sync "return Math.trunc(Math.abs(self_))"
+
+    round(): Float
+        target js sync "return Math.round(self_)"
+
+    floor(): Float
+        target js sync "return Math.floor(self_)"
+
+    ceil(): Float
+        target js sync "return Math.ceil(self_)"
+
+    truncate(): Float
+        target js sync "return Math.trunc(self_)"
+
+    sign(): Float
+        target js sync "return Math.sign(self_)"
+
+    abs(): Float
+        target js sync "return Math.abs(self_)"
+
+    toFixed(digits: Int): String
+        target js sync "return self_.toFixed(digits_)"
+
+    min(that: Float): Float {
+        if(self < that) {self} else {that}
+    }
+
+    max(that: Float): Float {
+        if(self > that) {self} else {that}
+    }
+
+    clamp(from: Float, to: Float): Float {
+        if(self <= from) {from} elseIf {self >= to} {to} else {self}
+    }
+
+}

package/core/HttpClient.ff

@@ -0,0 +1,84 @@
+capability HttpClient {}
+capability FetchBody {}
+capability FetchResponse {}
+data FetchRedirect {
+    RedirectFollow
+    RedirectError
+    RedirectManual
+}
+
+extend self: HttpClient {
+
+    fetch(
+        url: String
+        method: String = "GET"
+        headers: List[Pair[String, String]] = emptyList
+        body: Option[FetchBody] = None
+        redirect: FetchRedirect = RedirectFollow
+        // The rest of the options are only respected by browsers - see the MDN fetch() documentation
+        referrer: Option[String] = None
+        integrity: Option[String] = None
+        mode: Option[String] = None
+        credentials: Option[String] = None
+        cache: Option[String] = None
+        throw: Bool = True
+    ): FetchResponse
+        target js async """
+            try {
+                const options = {headers: {}, signal: $task.controller.signal}
+                options.method = method_
+                ff_core_List.List_each(headers_, pair => {options.headers[pair.key_] = pair.value_})
+                if(body_.value_) options.body = body_.value_
+                if(redirect_.RedirectError) options.redirect = "error"
+                else if(redirect_.RedirectManual) options.redirect = "manual"
+                if(referrer_.value_) options.referrer = referrer_.value_
+                if(integrity_.value_) options.integrity = integrity_.value_
+                if(mode_.value_) options.mode = mode_.value_
+                if(credentials_.value_) options.credentials = credentials_.value_
+                if(cache_.value_) options.cache = cache_.value_
+                let result = await fetch(url_, options)
+                if(throw_ && !result.ok) throw new Error("Unexpected HTTP status code: " + result.status)
+                return result
+            } finally {
+                if($task.controller.signal.aborted) $task.controller = new AbortController()
+            }
+        """
+
+}
+
+emptyList: List[Pair[String, String]] = [] // TODO: Why won't this type check when inlined? Probably some dangling unification variable?
+
+bodyText(body: String): FetchBody
+    target js sync "return body_"
+    target js async "return body_"
+
+bodyBuffer(body: Buffer): FetchBody
+    target js sync "return body_"
+    target js async "return body_"
+
+extend self: FetchResponse {
+
+    ok(): Bool
+        target js async "return self_.ok"
+
+    status(): Int
+        target js async "return self_.status"
+
+    statusText(): String
+        target js async "return self_.statusText"
+
+    header(name: String): Option[String]
+        target js async """
+            const header = self_.headers.get(name_)
+            return header != null
+                ? ff_core_Option.Some(header)
+                : ff_core_Option.None()
+        """
+
+    readText(): String
+        target js async "return await self_.text()"
+
+    readBuffer(): Buffer
+        target js async "return new DataView(await self_.arrayBuffer())"
+
+}

package/core/Instant.ff

@@ -0,0 +1,9 @@
+newtype Instant(since1970: Duration)
+
+extend self: Instant {
+
+    add(duration: Duration): Instant {
+        Instant(Duration(self.since1970.seconds + duration.seconds))
+    }
+
+}

package/core/Int.ff

@@ -0,0 +1,61 @@
+data Int {}
+
+extend self: Int {
+
+    abs(): Int
+        target js sync "return Math.abs(self_)"
+
+    toFloat(): Float
+        target js sync "return self_"
+
+    bitNot(): Int
+        target js sync "return ~self_;"
+
+    bitOr(that: Int): Int
+        target js sync "return self_ | that_;"
+
+    bitAnd(that: Int): Int
+        target js sync "return self_ & that_;"
+
+    bitXor(that: Int): Int
+        target js sync "return self_ ^ that_;"
+
+    bitLeft(bits: Int = 1): Int
+        target js sync "return self_ << bits_;"
+
+    bitRight(bits: Int = 1, signed: Bool = True): Int
+        target js sync "return signed_ ? self_ >> bits_ : self_ >>> bits_;"
+
+    to(inclusiveEnd: Int): List[Int] {
+        mutable result = []
+        mutable n = inclusiveEnd
+        while {self <= n} {
+            result = [n, ...result]
+            n -= 1
+        }
+        result
+    }
+
+    until(exclusiveEnd: Int): List[Int] {
+        mutable result = []
+        mutable n = exclusiveEnd
+        while {self < n} {
+            result = [n - 1, ...result]
+            n -= 1
+        }
+        result
+    }
+
+    min(that: Int): Int {
+        if(self < that) {self} else {that}
+    }
+
+    max(that: Int): Int {
+        if(self > that) {self} else {that}
+    }
+
+    clamp(from: Int, to: Int): Int {
+        if(self <= from) {from} elseIf {self >= to} {to} else {self}
+    }
+
+}