firefly-compiler 0.5.47 → 0.5.48

package/.vscode/settings.json

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

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/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/Map.ff

@@ -29,6 +29,14 @@ extend self[K: Order, V]: Map[K, V] {
     get(key: K): Option[V] {
         self.redBlack.get(key)
     }
+    
+    lastBefore(key: K): Option[Pair[K, V]] {
+        self.redBlack.lastBefore(key)
+    }
+    
+    firstAfter(key: K): Option[Pair[K, V]] {
+        self.redBlack.firstAfter(key)
+    }
 
     remove(key: K): Map[K, V] {
         Map(RbMap.delete(key, self.redBlack))

package/core/RbMap.ff

@@ -123,6 +123,22 @@ extend self[K: Order, V]: RB[K, V] {
             }
         }
     }
+    
+    lastBefore(key: K): Option[Pair[K, V]] {
+        self.{
+            | E => None
+            | T(_, l, k, v, r) {k >= key} => l.lastBefore(key)
+            | T(_, l, k, v, r) => r.lastBefore(key).orElse {Some(Pair(k, v))}
+        }
+    }
+    
+    firstAfter(key: K): Option[Pair[K, V]] {
+        self.{
+            | E => None
+            | T(_, l, k, v, r) {k <= key} => r.firstAfter(key)
+            | T(_, l, k, v, r) => l.firstAfter(key).orElse {Some(Pair(k, v))}
+        }
+    }
 
     size(): Int {
         self.{

package/core/Set.ff

@@ -17,6 +17,8 @@ extend self[T: Order]: Set[T] {
     remove(value: T): Set[T] {Set(self.map.remove(value))}
     removeAll(that: Set[T]): Set[T] {Set(self.map.removeAll(that.map))}
     contains(value: T): Bool {self.map.contains(value)}
+    lastBefore(key: T): Option[T] {self.map.lastBefore(key).map {_.first}}
+    firstAfter(key: T): Option[T] {self.map.firstAfter(key).map {_.first}}
     size(): Int {self.map.size()}
     toList(): List[T] {self.map.toList().map {_.first}}
     toStream(cycle: Bool = False): Stream[T] {self.map.toStream(cycle).map {_.first }}
@@ -41,4 +43,4 @@ instance Set[A: Show: Order]: Show {
     show(value: Set[A]): String {
         Show.show(value.toList()) + ".toSet()"
     }
-}
+}

package/experimental/IfBug.ff

@@ -0,0 +1,8 @@
+nodeMain(system: NodeSystem) {
+    let r = if(42 == 1) {
+        if(42 == 11) {
+            Log.debug("11")
+        }
+        Log.debug("1")
+    }
+}

package/lsp/LanguageServer.ff

@@ -117,6 +117,9 @@ taskGroup[K: Order, R](
 parseRequest(system: NodeSystem, input: Stream[Buffer]): Pair[Request, Stream[Buffer]] {
     let headersPair = parseRequestHeaders(input)
     let headers = headersPair.first
+    if(!headers.contains("content-length")) {
+        system.writeErrorLine(Show.show(headers.toList()))
+    }
     let contentLength = headers
         .get("content-length").else {throw(BadRequestException("'content-length' header is missing"))}
         .trim().getInt().else {throw(BadRequestException("Value for 'content-length' is not an integer"))}

package/output/js/ff/compiler/Builder.mjs

@@ -217,7 +217,26 @@ return (!ff_core_List.List_isEmpty(_w1.files_))
 })), for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const package_ = for_a[for_i];
 const firstFile_ = ff_core_List.List_grabFirst(package_.files_);
-const resolvedDependencies_ = ff_compiler_Dependencies.process_(ff_core_NodeSystem.NodeSystem_httpClient(system_), dependencyLock_, firstFile_);
+{
+const if_o = ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch(ff_core_Core.try_((() => {
+return ff_core_Option.Some(ff_compiler_Dependencies.process_(ff_core_NodeSystem.NodeSystem_httpClient(system_), dependencyLock_, firstFile_))
+})), ((_1, _2) => {
+{
+const c_ = _1;
+const error_ = _2;
+errors_.array.push(c_);
+return ff_core_Option.None()
+}
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError), ((_1, _2) => {
+{
+const compileErrors_ = _1.errors_;
+const error_ = _2;
+ff_core_Array.Array_pushList(errors_, compileErrors_);
+return ff_core_Option.None()
+}
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
+if(if_o.Some) {
+const resolvedDependencies_ = if_o.value_;
 const fixedPackagePaths_ = (ff_core_Map.Map_contains(resolvedDependencies_.packagePaths_, ff_compiler_Syntax.PackagePair("ff", "core"), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)
 ? resolvedDependencies_.packagePaths_
 : ff_core_Map.Map_add(resolvedDependencies_.packagePaths_, ff_compiler_Syntax.PackagePair("ff", "core"), ff_core_Path.Path_slash(fireflyPath_, "core"), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair));
@@ -257,6 +276,8 @@ return
 }), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
 };
 ff_compiler_ModuleCache.ModuleCache_mergeVersions(cache_, compiler_.cache_)
+}
+}
 };
 return ff_core_Array.Array_drain(errors_)
 }
@@ -439,7 +460,26 @@ return (!ff_core_List.List_isEmpty(_w1.files_))
 })), for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const package_ = for_a[for_i];
 const firstFile_ = ff_core_List.List_grabFirst(package_.files_);
-const resolvedDependencies_ = (await ff_compiler_Dependencies.process_$((await ff_core_NodeSystem.NodeSystem_httpClient$(system_, $task)), dependencyLock_, firstFile_, $task));
+{
+const if_o = ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch((await ff_core_Core.try_$((async ($task) => {
+return ff_core_Option.Some((await ff_compiler_Dependencies.process_$((await ff_core_NodeSystem.NodeSystem_httpClient$(system_, $task)), dependencyLock_, firstFile_, $task)))
+}), $task)), ((_1, _2) => {
+{
+const c_ = _1;
+const error_ = _2;
+errors_.array.push(c_);
+return ff_core_Option.None()
+}
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError), ((_1, _2) => {
+{
+const compileErrors_ = _1.errors_;
+const error_ = _2;
+ff_core_Array.Array_pushList(errors_, compileErrors_);
+return ff_core_Option.None()
+}
+}), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
+if(if_o.Some) {
+const resolvedDependencies_ = if_o.value_;
 const fixedPackagePaths_ = (ff_core_Map.Map_contains(resolvedDependencies_.packagePaths_, ff_compiler_Syntax.PackagePair("ff", "core"), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)
 ? resolvedDependencies_.packagePaths_
 : ff_core_Map.Map_add(resolvedDependencies_.packagePaths_, ff_compiler_Syntax.PackagePair("ff", "core"), (await ff_core_Path.Path_slash$(fireflyPath_, "core", $task)), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair));
@@ -479,6 +519,8 @@ return
 }), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
 };
 ff_compiler_ModuleCache.ModuleCache_mergeVersions(cache_, compiler_.cache_)
+}
+}
 };
 return ff_core_Array.Array_drain(errors_)
 }

package/output/js/ff/compiler/Dependencies.mjs

@@ -123,7 +123,9 @@ return {mainPackagePair_, packages_, packagePaths_, singleFilePackages_};
 export function process_(fetch_, dependencyLock_, path_) {
 const workspace_ = ff_compiler_Workspace.loadWorkspace_(path_);
 const self_ = ff_compiler_Dependencies.Dependencies(workspace_, ff_core_List.List_toMap([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toMap([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toSet([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair));
-const packageInfo_ = ff_compiler_Dependencies.Dependencies_loadPackageInfo(self_, ff_compiler_Syntax.PackagePair("script", "script"), path_);
+const packageInfo_ = ff_core_Option.Option_else(ff_compiler_Dependencies.Dependencies_loadPackageInfo(self_, ff_compiler_Syntax.PackagePair("script", "script"), path_), (() => {
+return ff_core_Core.panic_(("Not a main file: " + ff_core_Path.Path_absolute(path_)))
+}));
 const newDependencies_ = ff_compiler_Dependencies.Dependencies_processPackageInfo(self_, packageInfo_);
 ff_compiler_Dependencies.Dependencies_processDependencies(self_, path_, fetch_, dependencyLock_, newDependencies_);
 const packagePaths_ = ff_core_Map.Map_add(self_.packagePaths_, packageInfo_.package_.packagePair_, ff_compiler_Dependencies.findScriptPackageLocation_(path_), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair);
@@ -161,7 +163,9 @@ tar_.extract({file: tarGzPath_.absolutePath_, cwd: path_.absolutePath_, strict:
 export async function process_$(fetch_, dependencyLock_, path_, $task) {
 const workspace_ = (await ff_compiler_Workspace.loadWorkspace_$(path_, $task));
 const self_ = ff_compiler_Dependencies.Dependencies(workspace_, ff_core_List.List_toMap([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toMap([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toSet([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair));
-const packageInfo_ = (await ff_compiler_Dependencies.Dependencies_loadPackageInfo$(self_, ff_compiler_Syntax.PackagePair("script", "script"), path_, $task));
+const packageInfo_ = (await ff_core_Option.Option_else$((await ff_compiler_Dependencies.Dependencies_loadPackageInfo$(self_, ff_compiler_Syntax.PackagePair("script", "script"), path_, $task)), (async ($task) => {
+return ff_core_Core.panic_(("Not a main file: " + (await ff_core_Path.Path_absolute$(path_, $task))))
+}), $task));
 const newDependencies_ = (await ff_compiler_Dependencies.Dependencies_processPackageInfo$(self_, packageInfo_, $task));
 (await ff_compiler_Dependencies.Dependencies_processDependencies$(self_, path_, fetch_, dependencyLock_, newDependencies_, $task));
 const packagePaths_ = ff_core_Map.Map_add(self_.packagePaths_, packageInfo_.package_.packagePair_, (await ff_compiler_Dependencies.findScriptPackageLocation_$(path_, $task)), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair);
@@ -204,8 +208,11 @@ const sharedPackageFile_ = ff_core_Path.Path_slash(ff_core_Path.Path_slash(packa
 const packageFile_ = (ff_core_Path.Path_exists(sharedPackageFile_, false, false, false)
 ? sharedPackageFile_
 : (self_.singleFilePackages_ = ff_core_Set.Set_add(self_.singleFilePackages_, packagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), path_));
-const code_ = ff_core_Path.Path_readText(packageFile_);
-return ff_compiler_Dependencies.Dependencies_parsePackageFile(self_, packagePair_, ff_core_Path.Path_relativeTo(packageFile_, path_), code_)
+return ff_core_Option.Option_map(ff_core_Try.Try_toOption(ff_core_Core.try_((() => {
+return ff_core_Path.Path_readText(packageFile_)
+}))), ((code_) => {
+return ff_compiler_Dependencies.Dependencies_parsePackageFile(self_, packagePair_, ff_core_Path.Path_absolute(packageFile_), code_)
+}))
 }
 
 export function Dependencies_parsePackageFile(self_, packagePair_, fileName_, code_) {
@@ -258,7 +265,7 @@ return ff_core_Option.Some((function() {
 ff_core_Log.trace_(("Fetching " + location_));
 const buffer_ = ff_core_HttpClient.HttpClient_get(httpClient_, location_, [], ((response_) => {
 if((!ff_core_HttpClient.FetchResponse_ok(response_))) {
-ff_core_Core.panic_(("Could not download dependency: " + location_))
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(dependency_.at_, ("Could not download dependency: " + location_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
 return ff_core_HttpClient.FetchResponse_readBuffer(response_)
 }));
@@ -275,7 +282,7 @@ return ff_core_Path.Path_renameTo(tarGzPath_, donePath_)
 };
 return dependencyPath_
 } else {
-return ff_core_Core.panic_(("Loading packages by this protocol is not supported: " + location_))
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(dependency_.at_, ("Loading packages by this protocol is not supported: " + location_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }
 } else {
 return ff_core_Path.Path_path(path_, location_)
@@ -286,7 +293,9 @@ export function Dependencies_processDependencies(self_, path_, httpClient_, depe
 const packageInfos_ = ff_core_List.List_map(dependencies_, ((dependency_) => {
 const dependencyPath_ = ff_compiler_Dependencies.Dependencies_fetchDependency(self_, path_, httpClient_, dependencyLock_, dependency_);
 self_.packagePaths_ = ff_core_Map.Map_add(self_.packagePaths_, dependency_.packagePair_, dependencyPath_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair);
-const packageInfo_ = ff_compiler_Dependencies.Dependencies_loadPackageInfo(self_, dependency_.packagePair_, dependencyPath_);
+const packageInfo_ = ff_core_Option.Option_else(ff_compiler_Dependencies.Dependencies_loadPackageInfo(self_, dependency_.packagePair_, dependencyPath_), (() => {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(dependency_.at_, ("Dependency not found: " + ff_core_Path.Path_absolute(dependencyPath_))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+}));
 ff_compiler_Dependencies.checkPackagePairs_(dependency_.packagePair_, packageInfo_.package_.packagePair_);
 return packageInfo_
 }));
@@ -306,8 +315,11 @@ const sharedPackageFile_ = (await ff_core_Path.Path_slash$((await ff_core_Path.P
 const packageFile_ = ((await ff_core_Path.Path_exists$(sharedPackageFile_, false, false, false, $task))
 ? sharedPackageFile_
 : (self_.singleFilePackages_ = ff_core_Set.Set_add(self_.singleFilePackages_, packagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), path_));
-const code_ = (await ff_core_Path.Path_readText$(packageFile_, $task));
-return (await ff_compiler_Dependencies.Dependencies_parsePackageFile$(self_, packagePair_, (await ff_core_Path.Path_relativeTo$(packageFile_, path_, $task)), code_, $task))
+return (await ff_core_Option.Option_map$(ff_core_Try.Try_toOption((await ff_core_Core.try_$((async ($task) => {
+return (await ff_core_Path.Path_readText$(packageFile_, $task))
+}), $task))), (async (code_, $task) => {
+return (await ff_compiler_Dependencies.Dependencies_parsePackageFile$(self_, packagePair_, (await ff_core_Path.Path_absolute$(packageFile_, $task)), code_, $task))
+}), $task))
 }
 
 export async function Dependencies_parsePackageFile$(self_, packagePair_, fileName_, code_, $task) {
@@ -360,7 +372,7 @@ return ff_core_Option.Some((await (async function() {
 ff_core_Log.trace_(("Fetching " + location_));
 const buffer_ = (await ff_core_HttpClient.HttpClient_get$(httpClient_, location_, [], (async (response_, $task) => {
 if((!(await ff_core_HttpClient.FetchResponse_ok$(response_, $task)))) {
-ff_core_Core.panic_(("Could not download dependency: " + location_))
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(dependency_.at_, ("Could not download dependency: " + location_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
 return (await ff_core_HttpClient.FetchResponse_readBuffer$(response_, $task))
 }), $task));
@@ -377,7 +389,7 @@ return (await ff_core_Path.Path_renameTo$(tarGzPath_, donePath_, $task))
 };
 return dependencyPath_
 } else {
-return ff_core_Core.panic_(("Loading packages by this protocol is not supported: " + location_))
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(dependency_.at_, ("Loading packages by this protocol is not supported: " + location_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }
 } else {
 return (await ff_core_Path.Path_path$(path_, location_, $task))
@@ -388,7 +400,9 @@ export async function Dependencies_processDependencies$(self_, path_, httpClient
 const packageInfos_ = (await ff_core_List.List_map$(dependencies_, (async (dependency_, $task) => {
 const dependencyPath_ = (await ff_compiler_Dependencies.Dependencies_fetchDependency$(self_, path_, httpClient_, dependencyLock_, dependency_, $task));
 self_.packagePaths_ = ff_core_Map.Map_add(self_.packagePaths_, dependency_.packagePair_, dependencyPath_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair);
-const packageInfo_ = (await ff_compiler_Dependencies.Dependencies_loadPackageInfo$(self_, dependency_.packagePair_, dependencyPath_, $task));
+const packageInfo_ = (await ff_core_Option.Option_else$((await ff_compiler_Dependencies.Dependencies_loadPackageInfo$(self_, dependency_.packagePair_, dependencyPath_, $task)), (async ($task) => {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(dependency_.at_, ("Dependency not found: " + (await ff_core_Path.Path_absolute$(dependencyPath_, $task)))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+}), $task));
 ff_compiler_Dependencies.checkPackagePairs_(dependency_.packagePair_, packageInfo_.package_.packagePair_);
 return packageInfo_
 }), $task));