firefly-compiler 0.5.47 → 0.5.49

package/.vscode/settings.json

@@ -1,5 +1,5 @@
 {
     "editor.suggest.showWords": false,
-    "firefly.trace.server": "messages",
+    "firefly.trace.server": "verbose",
     "editor.trimAutoWhitespace": false
 }

package/bin/firefly.mjs

@@ -1,2 +1,2 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --harmony-temporal
 import * as firefly from '../output/js/ff/compiler/Main.mjs';

package/compiler/Builder.ff

@@ -136,7 +136,15 @@ check(
 
     packages.filter {!_.files.isEmpty()}.each {package => 
         let firstFile = package.files.grabFirst()
-        let resolvedDependencies = Dependencies.process(system.httpClient(), dependencyLock, firstFile)
+        try {
+            Some(Dependencies.process(system.httpClient(), dependencyLock, firstFile))
+        } tryCatch {| CompileError(_, _) @ c, error =>
+            errors.push(c)
+            None
+        } catch {| CompileErrors(compileErrors), error =>
+            errors.pushList(compileErrors)
+            None
+        }.each: resolvedDependencies => 
         let fixedPackagePaths = if(resolvedDependencies.packagePaths.contains(PackagePair("ff", "core"))) {
             resolvedDependencies.packagePaths
         } else {

package/compiler/Compiler.ff

@@ -67,13 +67,13 @@ coreImports: List[DImport] =
         "Char"
         "Core"
         "Crypto"
+        "Date"
         "Duration"
         "Equal"
         "Error"
         "FileHandle"
         "Float"
         "HttpClient"
-        "Instant"
         "Int"
         "IntMap"
         "Json"

package/compiler/Dependencies.ff

@@ -24,7 +24,7 @@ extend self: Dependencies {
     loadPackageInfo(
         packagePair: PackagePair
         path: Path
-    ): PackageInfo {
+    ): Option[PackageInfo] {
         let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
         let sharedPackageFile = packageDirectory.slash(".firefly").slash("package.ff")
         let packageFile = if(sharedPackageFile.exists()) {
@@ -33,8 +33,8 @@ extend self: Dependencies {
             self.singleFilePackages = self.singleFilePackages.add(packagePair)
             path
         }
-        let code = packageFile.readText()
-        self.parsePackageFile(packagePair, packageFile.relativeTo(path), code)
+        try {packageFile.readText()}.toOption().map: code =>
+        self.parsePackageFile(packagePair, packageFile.absolute(), code)
     }
     
     parsePackageFile(
@@ -93,7 +93,7 @@ extend self: Dependencies {
                             Log.trace("Fetching " + location)
                             let buffer = httpClient.get(location, []) {response =>
                                 if(!response.ok()) {
-                                    panic("Could not download dependency: " + location)
+                                    throw(CompileError(dependency.at, "Could not download dependency: " + location))
                                 }
                                 response.readBuffer()
                             }
@@ -109,7 +109,7 @@ extend self: Dependencies {
                 }
                 dependencyPath
             } else {
-                panic("Loading packages by this protocol is not supported: " + location)
+                throw(CompileError(dependency.at, "Loading packages by this protocol is not supported: " + location))
             }
         } else {
             path.path(location)
@@ -126,7 +126,9 @@ extend self: Dependencies {
         let packageInfos = dependencies.map {dependency =>
             let dependencyPath = self.fetchDependency(path, httpClient, dependencyLock, dependency)
             self.packagePaths = self.packagePaths.add(dependency.packagePair, dependencyPath)
-            let packageInfo = self.loadPackageInfo(dependency.packagePair, dependencyPath)
+            let packageInfo = self.loadPackageInfo(dependency.packagePair, dependencyPath).else {
+                throw(CompileError(dependency.at, "Dependency not found: " + dependencyPath.absolute()))
+            }
             checkPackagePairs(dependency.packagePair, packageInfo.package.packagePair)
             packageInfo
         }
@@ -141,7 +143,9 @@ extend self: Dependencies {
 process(fetch: HttpClient, dependencyLock: DependencyLock, path: Path): ResolvedDependencies {
     let workspace = Workspace.loadWorkspace(path)
     let self = Dependencies(workspace, [].toMap(), [].toMap(), [].toSet())
-    let packageInfo = self.loadPackageInfo(PackagePair("script", "script"), path)
+    let packageInfo = self.loadPackageInfo(PackagePair("script", "script"), path).else {
+        panic("Not a main file: " + path.absolute())
+    }
     let newDependencies = self.processPackageInfo(packageInfo)
     self.processDependencies(path, fetch, dependencyLock, newDependencies)
     let packagePaths = self.packagePaths.add(packageInfo.package.packagePair, findScriptPackageLocation(path))

package/compiler/JsEmitter.ff

@@ -279,7 +279,7 @@ extend self: JsEmitter {
         }
     }
 
-    emitTerm(term: Term, async: Bool): String {term.{
+    emitTerm(term: Term, async: Bool, ignored: Bool = False): String {term.{
         | EString(at, value) {value.startsWith("\"\"\"")} =>
             "`" + value.dropFirst(3).dropLast(3).replace("`", "\\`") + "`" // TODO: Fix escaping
         | EString(at, value) => value
@@ -347,6 +347,8 @@ extend self: JsEmitter {
             let c = if(await) {", $task"} else {""}
             let call = "(" + self.emitTerm(function, async) + ")(" + self.emitTerm(value, async) + c + ")"
             if(await) {"(await " + call + ")"} else {call}
+        | _ {self.emitAssignment(term, async) | Some(code)} =>
+            if(ignored) {code} else {"(" + code + ", void 0)"}
         | ECall(at, StaticCall(name, _, _), _, _, arguments, dictionaries) {
             self.emitSpecialCall(term, async, name, arguments.map {_.value}, dictionaries) | Some(code)
         } =>
@@ -379,14 +381,14 @@ extend self: JsEmitter {
                     let call = functionCode + "(" + [...emittedArguments, ...ds, ...controller].join(", ") + ")"
                     if(await) {"(await " + call + ")"} else {call}
                 | [Pair(EVariant(_, "ff:core/Bool.True", _, _), elseBody), ...list] =>
-                    "(" + list.foldLeft(self.emitComma(elseBody, async)) {| otherwise, Pair(condition, body) =>
-                        self.emitComma(condition, async) +
-                        "\n? " + self.emitComma(body, async) + "\n: " + otherwise
+                    "(" + list.foldLeft(self.emitTerm(elseBody, async)) {| otherwise, Pair(condition, body) =>
+                        self.emitTerm(condition, async) +
+                        "\n? " + self.emitTerm(body, async) + "\n: " + otherwise
                     } + ")"
                 | list =>
                     "(" + list.foldLeft("ff_core_Option.None()") {| otherwise, Pair(condition, body) =>
-                        self.emitComma(condition, async) +
-                        "\n? ff_core_Option.Some(" + self.emitComma(body, async) + ")\n: " + otherwise
+                        self.emitTerm(condition, async) +
+                        "\n? ff_core_Option.Some(" + self.emitTerm(body, async) + ")\n: " + otherwise
                     } + ")"
             }
         | ECall(at, DynamicCall(function, _), effect, typeArguments, arguments, dictionaries) =>
@@ -405,6 +407,24 @@ extend self: JsEmitter {
         | EWildcard(at, index) =>
             if(index == 0) {fail(at, "Unbound wildcard")}
             "_w" + index
+        | ESequential(_, ESequential(_, ESequential(_, before1, before2), before3), after) {
+            safeCommable(before1) && safeCommable(before2) && safeCommable(before3) && safeCommable(after)
+        } =>
+            "(" + self.emitTerm(before1, async, ignored = True) + ", " + 
+            self.emitTerm(before2, async, ignored = True) + ", " + 
+            self.emitTerm(before3, async, ignored = True) + ", " + 
+            self.emitTerm(after, async, ignored) + ")"
+        | ESequential(_, ESequential(_, before1, before2), after) {
+            safeCommable(before1) && safeCommable(before2) && safeCommable(after)
+        } =>
+            "(" + self.emitTerm(before1, async, ignored = True) + ", " + 
+            self.emitTerm(before2, async, ignored = True) + ", " + 
+            self.emitTerm(after, async, ignored) + ")"
+        | ESequential(_, before, after) {
+            safeCommable(before) && safeCommable(after)
+        } =>
+            "(" + self.emitTerm(before, async, ignored = True) + ", " + 
+            self.emitTerm(after, async, ignored) + ")"
         | _ {async} =>
             "(await (async function() {\n" + self.emitStatements(term, True, False, async) + "\n})())"
         | _ =>
@@ -450,11 +470,6 @@ extend self: JsEmitter {
             | ESequential(at, before, after) =>
                 self.emitStatements(before, False, False, async) + ";\n" + 
                 self.emitStatements(after, last, break, async)
-            | EAssign(at, operator, name, value) =>
-                escapeKeyword(name) + " " + operator + "= " + self.emitTerm(value, async)
-            | EAssignField(at, operator, record, field, value) =>
-                self.emitTerm(record, async) + "." + escapeKeyword(field) + " " + operator + "= " +
-                self.emitTerm(value, async)
             | ECall(at, StaticCall(name, True, instanceCall), effect, _, arguments, _) =>
                 if(instanceCall) {throw(CompileError(at, "Not yet implemented: Tail calls on trait methods."))}
                 self.tailCallUsed = True
@@ -478,15 +493,17 @@ extend self: JsEmitter {
                     self.emitCase(["_1"], c, [], [], True, last, break, lastCase, async)
                 }.join("\n") +
                 "\n}" + if(!last && !break) {" while(false)"}.else {""}
+            | _ {self.emitAssignment(term, async) | Some(code)} =>
+                code
             | _ =>
                 detectIfElse(term).{
                     | [] =>
                         if(break) {
-                            "if(!" + self.emitComma(term, async) + ") break"
+                            "if(!" + self.emitTerm(term, async) + ") break"
                         } elseIf {last} {
                             "return " + self.emitTerm(term, async)
                         } else {
-                            self.emitTerm(term, async)
+                            self.emitTerm(term, async, ignored = True)
                         }
                     | [Pair(EVariant(_, "ff:core/Bool.True", _, _), elseBody), ...list] =>
                         let initial = "{\n" + self.emitStatements(elseBody, last, break, async) + "\n}"
@@ -508,6 +525,49 @@ extend self: JsEmitter {
         }
     }
     
+    emitAssignment(
+        term: Term
+        async: Bool
+    ): Option[String] {
+        | ECall(at, StaticCall(name, _, _), _, _, arguments, dictionaries), _ =>
+            name.{
+                | "ff:core/JsValue.JsValue_set" {arguments.map {_.value} | [e1, e2, e3]} =>
+                    Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " = " + self.emitTerm(e3, async))
+                | "ff:core/JsValue.JsValue_increment" {arguments.map {_.value} | [e1, e2, e3]} =>
+                    Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " += " + self.emitTerm(e3, async))
+                | "ff:core/JsValue.JsValue_decrement" {arguments.map {_.value} | [e1, e2, e3]} =>
+                    Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " -= " + self.emitTerm(e3, async))
+                | "ff:core/JsSystem.JsSystem_set" {arguments.map {_.value} | [e1, EString(_, q), e3]} {
+                    noSideEffects(e1)} {safeBare(q) | Some(s)
+                } =>
+                    Some(s + " = " + self.emitTerm(e3, async))
+                | "ff:core/JsSystem.JsSystem_increment" {arguments.map {_.value} | [e1, EString(_, q), e3]} {
+                    noSideEffects(e1)} {safeBare(q) | Some(s)
+                } =>
+                    Some(s + " += " + self.emitTerm(e3, async))
+                | "ff:core/JsSystem.JsSystem_decrement" {arguments.map {_.value} | [e1, EString(_, q), e3]} {
+                    noSideEffects(e1)} {safeBare(q) | Some(s)
+                } =>
+                    Some(s + " -= " + self.emitTerm(e3, async))
+                | "ff:core/Js.set" {arguments.map {_.value} | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
+                    Some(s + " = " + self.emitTerm(e2, async))
+                | "ff:core/Js.increment" {arguments.map {_.value} | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
+                    Some(s + " += " + self.emitTerm(e2, async))
+                | "ff:core/Js.decrement" {arguments.map {_.value} | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
+                    Some(s + " -= " + self.emitTerm(e2, async))
+                | _ => None
+            }
+        | EAssign(at, operator, name, value), _ =>
+            Some(escapeKeyword(name) + " " + operator + "= " + self.emitTerm(value, async))
+        | EAssignField(at, operator, record, field, value), _ =>
+            Some(
+                self.emitTerm(record, async) + "." + escapeKeyword(field) + " " + operator + "= " +
+                self.emitTerm(value, async)
+            )
+        | _, _ =>
+            None
+    }
+    
     emitSpecialCall(
         term: Term
         async: Bool
@@ -794,7 +854,7 @@ extend self: JsEmitter {
         name.{
             | "ff:core/Core.while" {arguments | [condition, body]} =>
                 Some(
-                    "while(" + self.emitComma(invokeImmediately(condition), async) + ") {\n" +
+                    "while(" + self.emitTerm(invokeImmediately(condition), async) + ") {\n" +
                     self.emitStatements(invokeImmediately(body), False, False, async) + "\n}"
                 )
             | "ff:core/Core.doWhile" {arguments | [doWhileBody]} {
@@ -906,7 +966,7 @@ extend self: JsEmitter {
                 Some(self.emitTerm(array, async) + ".array.push(" + self.emitTerm(value, async) + ")")
             | "ff:core/Core.if" {arguments | [condition, body]} =>
                 Some(
-                    "if(" + self.emitComma(condition, async) + ") {\n" +
+                    "if(" + self.emitTerm(condition, async) + ") {\n" +
                     if(last) {
                         "return ff_core_Option.Some(" + self.emitTerm(invokeImmediately(body), async) +
                         ")\n} else return ff_core_Option.None()"
@@ -928,24 +988,6 @@ extend self: JsEmitter {
                 Some(if(async) {"ff_core_Task.Task_throwIfAborted($task)"} else {""})
             | "ff:core/Js.throw" {term | ECall c} {c.arguments | [argument]} =>
                 Some("throw " + self.emitTerm(argument.value, async))
-            | "ff:core/JsValue.JsValue_set" {arguments | [e1, e2, e3]} =>
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " = " + self.emitTerm(e3, async))
-            | "ff:core/JsValue.JsValue_increment" {arguments | [e1, e2, e3]} =>
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " += " + self.emitTerm(e3, async))
-            | "ff:core/JsValue.JsValue_decrement" {arguments | [e1, e2, e3]} =>
-                Some(self.emitTerm(e1, async) + self.emitField(e2, async) + " -= " + self.emitTerm(e3, async))
-            | "ff:core/JsSystem.JsSystem_set" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
-                Some(s + " = " + self.emitTerm(e3, async))
-            | "ff:core/JsSystem.JsSystem_increment" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
-                Some(s + " += " + self.emitTerm(e3, async))
-            | "ff:core/JsSystem.JsSystem_decrement" {arguments | [e1, EString(_, q), e3]} {noSideEffects(e1)} {safeBare(q) | Some(s)} =>
-                Some(s + " -= " + self.emitTerm(e3, async))
-            | "ff:core/Js.set" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
-                Some(s + " = " + self.emitTerm(e2, async))
-            | "ff:core/Js.increment" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
-                Some(s + " += " + self.emitTerm(e2, async))
-            | "ff:core/Js.decrement" {arguments | [EString(_, q), e2]} {safeBare(q) | Some(s)} =>
-                Some(s + " -= " + self.emitTerm(e2, async))
             | _ =>
                 None
         }
@@ -1280,31 +1322,6 @@ extend self: JsEmitter {
         }
     }
     
-    emitComma(term: Term, async: Bool): String {
-        term.{
-            | ESequential(_, ESequential(_, ESequential(_, before1, before2), before3), after) {
-                safeCommable(before1) && safeCommable(before2) && safeCommable(before3) && safeCommable(after)
-            } =>
-                "(" + self.emitStatements(before1, False, False, async) + ", " + 
-                self.emitStatements(before2, False, False, async) + ", " + 
-                self.emitStatements(before3, False, False, async) + ", " + 
-                self.emitTerm(after, async) + ")"
-            | ESequential(_, ESequential(_, before1, before2), after) {
-                safeCommable(before1) && safeCommable(before2) && safeCommable(after)
-            } =>
-                "(" + self.emitStatements(before1, False, False, async) + ", " + 
-                self.emitStatements(before2, False, False, async) + ", " + 
-                self.emitTerm(after, async) + ")"
-            | ESequential(_, before, after) {
-                safeCommable(before) && safeCommable(after)
-            } =>
-                "(" + self.emitStatements(before, False, False, async) + ", " + 
-                self.emitTerm(after, async) + ")"
-            | _ =>
-                self.emitTerm(term, async)
-        }
-    }
-
 }
 
 data ProcessedVariantCase(

package/core/BrowserSystem.ff

@@ -18,6 +18,11 @@ extend self: BrowserSystem {
         Js.globalThis()?
     }
         
+    date(timeZoneId: Option[String] = None, calendarId: String = Date.isoCalendarId): Date {
+        let date = Date(Js->Temporal->Now->zonedDateTimeISO(timeZoneId.map {_!}.else {Js.undefined()}))
+        if(calendarId == Date.isoCalendarId) {date} else {date.withCalendar(calendarId)}
+    }
+
     url(): String {
         Js->location->href?
     }