firefly-compiler 0.4.31 → 0.4.33

package/lsp/Handler.ff

@@ -8,6 +8,7 @@ import Environment from ff:compiler
 import Unification from ff:compiler
 import LspHook from ff:compiler
 import ModuleCache from ff:compiler
+import DependencyLock from ff:compiler
 import HoverHandler
 import CompletionHandler
 import SignatureHelpHandler
@@ -21,6 +22,7 @@ capability Handler(
     mutable responseCache: Map[TokenRequestCacheKey, ResultOrError]
     mutable fileSymbolsCache: Map[String, List[DocumentSymbol]]
     moduleCache: ModuleCache
+    dependencyLock: DependencyLock
 )
 
 data TokenRequestCacheKey(
@@ -60,6 +62,9 @@ extend self: Handler {
         method.{
             | "initialized" =>
                 []
+            | "textDocument/didOpen" => 
+                self.handleDidOpen(system, parameters)
+                []
             | "textDocument/didChange" => 
                 self.handleDidChange(system, parameters)
                 let diagnostics = self.handleFocusDiagnostic(system, parameters, version)
@@ -145,7 +150,7 @@ extend self: Handler {
     }
 
     handleInitialize(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
-        self.rootPath = Some(system.pathFromUrl(parameters.grab("rootUri").grabString()))
+        self.rootPath = parameters.grab("rootUri").getString().map {system.pathFromUrl(_)}
 
         let anyFireflyFile = Json.object()
             .with("filters", [
@@ -206,12 +211,12 @@ extend self: Handler {
         Result(o.write())
     }
 
-    handleDiagnostic(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
+    /*handleDiagnostic(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
         let js = system.js()
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         let fireflyPath = system.path(".")
-        let errors = self.check(system, fireflyPath, path, None, Set.empty(), self.virtualFiles, version, LspHook.disabled(), True)
+        let errors = self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, LspHook.disabled(), True)
         let diagnostics = errors.map {| CompileError(at, message) => 
             let tokenLocation = self.findToken(system, at)
             Json.object()
@@ -223,15 +228,15 @@ extend self: Handler {
             .with("kind", "full")
             .with("items", diagnostics)
         Result(o.write())
-    }
+    }*/
 
     handleFocusDiagnostic(system: NodeSystem, parameters: Map[String, Json], version: Int): Json {
         let js = system.js()
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         let fireflyPath = system.path(".")
-        let errors = self.check(system, fireflyPath, path, None, Set.empty(), self.virtualFiles, version, LspHook.disabled(), True)
-        let diagnostics = errors.map {| CompileError(at, message) => 
+        let errors = self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, LspHook.disabled(), True)
+        let diagnostics = errors.filter {_.at.file == path.absolute()}.map {| CompileError(at, message) => 
             let tokenLocation = self.findToken(system, at)
             Json.object()
                 .with("range", self.tokenLocationToLspRange(tokenLocation))
@@ -265,10 +270,10 @@ extend self: Handler {
 
     getDocumentSymbols(system: NodeSystem, path: Path): List[DocumentSymbol] {
         try {
-            let lspHook = LspHook.make(at = None, definedAt = None, insertIdentifier = False, trackSymbols = True)
+            let lspHook = LspHook.new(at = None, definedAt = None, insertIdentifier = False, trackSymbols = True)
             let code = self.virtualFiles.get(path.absolute()).else {path.readText()}
             let tokens = Tokenizer.tokenize(path.absolute(), code, None, True)
-            let parser = Parser.make(PackagePair("script", "script"), path.absolute(), tokens, False, lspHook)
+            let parser = Parser.new(PackagePair("script", "script"), path.absolute(), tokens, False, lspHook)
             parser.parseModuleWithPackageInfo()
             SymbolHandler.readAllSymbols(lspHook.results())
         } catch {| CompileError(at, message), error =>
@@ -294,8 +299,14 @@ extend self: Handler {
     }
 
     handleWorkspaceSymbol(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
+        self.rootPath.or {Error(-32803 /*Request Failed*/, "Open a folder to enable workspace symbols")}: rootPath =>
+        let files = if(rootPath.isFile()) {
+            [rootPath]
+        } else {
+            self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(rootPath, None, Set.new())}
+        }
+        let root = if(rootPath.isFile()) {rootPath.parent().grab()} else {rootPath}
         let query = parameters.grab("query").grabString()
-        let files = self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(self.rootPath.grab(), None, Set.empty())}
         let symbols = files.flatMap {file => 
             let documentSymbols = self.getDocumentSymbolsWithCache(system, file)
             let workspaceSymbols = documentSymbols.flatMap {SymbolHandler.documentToWorkspaceSymbols(_, None)}
@@ -306,7 +317,7 @@ extend self: Handler {
             }
         }
         let limitedSymbols = symbols.sortBy {_.name.size()}.takeFirst(100)
-        let jsSymbols = limitedSymbols.map {SymbolHandler.workspaceSymbolToLsp(self.rootPath.grab(), _)}
+        let jsSymbols = limitedSymbols.map {SymbolHandler.workspaceSymbolToLsp(root, _)}
         Result(Json.array(jsSymbols).write())
     }
     
@@ -321,10 +332,19 @@ extend self: Handler {
         diagnostics.map {Pair("textDocument/publishDiagnostics", _)}
     }
     
+    handleDidOpen(system: NodeSystem, parameters: Map[String, Json]): Unit {
+        let uri = parameters.grab("textDocument").field("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        if(self.rootPath.isEmpty()) {
+            Log.trace("Using file as rootPath: " + path.absolute())
+            self.rootPath = Some(path)
+        }
+    }
+
     handleDidChange(system: NodeSystem, parameters: Map[String, Json]): Unit {
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
-        self.responseCache = Map.empty()
+        self.responseCache = Map.new()
         self.fileSymbolsCache = self.fileSymbolsCache.remove(path.absolute())
         self.moduleCache.invalidate(path.absolute())
         let contentChanges = parameters.grab("contentChanges").grabArray()
@@ -342,9 +362,9 @@ extend self: Handler {
     }
 
     handleHover(system: NodeSystem, targetAt: Location, goToDefinition: Bool, version: Int): ResultOrError {
-        let lspHook = LspHook.make(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+        let lspHook = LspHook.new(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
         let path = system.path(targetAt.file)
-        let errors = self.check(system, self.fireflyPath, path, None, Set.empty(), self.virtualFiles, version, lspHook, True)
+        let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
         errors.each {| CompileError(at, message) => 
             Log.trace("handleHover check error: " + message)
         }
@@ -364,9 +384,9 @@ extend self: Handler {
             line = token.startLine
             column = token.startColumn
         )
-        let lspHook = LspHook.make(at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False)
+        let lspHook = LspHook.new(at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False)
         let path = system.path(completionAt.file)
-        let errors = self.check(system, self.fireflyPath, path, None, Set.empty(), self.virtualFiles, version, lspHook, True)
+        let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
         errors.each {| CompileError(at, message) => 
             Log.trace("handleCompletion check error: " + message)
         }        
@@ -376,11 +396,11 @@ extend self: Handler {
 
     handleSignatureHelp(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
         let cursorAt = self.findLocationFromParameters(system, parameters)
-        let lspHook = LspHook.make(at = Some(cursorAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+        let lspHook = LspHook.new(at = Some(cursorAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
         try {
             let code = self.virtualFiles.get(cursorAt.file).else {system.path(cursorAt.file).readText()}
             let tokens = Tokenizer.tokenize(cursorAt.file, code, None, True)
-            let parser = Parser.make(PackagePair("script", "script"), cursorAt.file, tokens, False, lspHook)
+            let parser = Parser.new(PackagePair("script", "script"), cursorAt.file, tokens, False, lspHook)
             parser.parseModuleWithPackageInfo()
         } catch {| CompileError(at, message), error =>
             Log.trace("handleSignatureHelp check error: " + message)
@@ -397,9 +417,9 @@ extend self: Handler {
             } => 
                 Some(SignatureHelpHandler.pickActiveParameter(help, h.argumentIndex, h.parameterName))
             | ParseArgumentHook h => 
-                let callLspHook = LspHook.make(at = Some(h.callAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+                let callLspHook = LspHook.new(at = Some(h.callAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
                 let path = system.path(cursorAt.file)
-                let errors = self.check(system, self.fireflyPath, path, None, Set.empty(), self.virtualFiles, version, callLspHook, True)
+                let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, callLspHook, True)
                 errors.each {| CompileError(at, message) => 
                     Log.trace("handleSignatureHelp check 2 error: " + message)
                 }        
@@ -462,9 +482,9 @@ extend self: Handler {
         includeDeclaration: Bool
         version: Int
     ): Option[List[TokenLocation]] {
-        let temporaryLspHook = LspHook.make(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+        let temporaryLspHook = LspHook.new(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
         let path = system.path(targetAt.file)
-        let errors = self.check(system, self.fireflyPath, path, None, Set.empty(), self.virtualFiles, version, temporaryLspHook, True)
+        let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, temporaryLspHook, True)
         errors.each {| CompileError(at, message) => 
             Log.trace("findReferences first check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
         }  
@@ -508,9 +528,9 @@ extend self: Handler {
 
         definedAtList.first().{
             | Some(definition) =>
-                let lspHook = LspHook.make(at = None, definedAt = Some(definition.at), insertIdentifier = False, trackSymbols = False)
+                let lspHook = LspHook.new(at = None, definedAt = Some(definition.at), insertIdentifier = False, trackSymbols = False)
                 let localCheck = local || definition.local
-                let path = if(localCheck) {system.path(targetAt.file)} else {self.rootPath.grab()}
+                let path = if(localCheck) {system.path(targetAt.file)} else {self.rootPath.else {system.path(targetAt.file)}}
                 let mustContain = Some(definition.name).filter {_ => !localCheck}.map(unqualify)
                 Log.trace("findReferences definition: " + Show.show(definition))
                 mustContain.each {Log.trace("mustContain: " + _)}
@@ -524,7 +544,7 @@ extend self: Handler {
                         list.toSet()
                     }.else {
                         Log.trace("No skip list due to unqualified definition.name: " + definition.name)
-                        Set.empty()
+                        Set.new()
                     }
                 }
                 let errors = self.check(system, self.fireflyPath, path, mustContain, skipFiles, self.virtualFiles, version, lspHook, True, False)
@@ -683,6 +703,7 @@ extend self: Handler {
             skipFiles
             virtualFiles
             self.moduleCache
+            self.dependencyLock
             newModuleCacheVersion
             lspHook
             infer

package/lsp/LanguageServer.ff

@@ -1,4 +1,5 @@
 import ModuleCache from ff:compiler
+import DependencyLock from ff:compiler
 import Handler
 
 class LanguageServer(
@@ -29,8 +30,17 @@ main(system: NodeSystem) {
     }
     
     let fireflyPath = system.path(".")
-    let cache = ModuleCache.empty(0)
-    let handler = Handler(fireflyPath, None, Map.empty(), [].toSet(), Map.empty(), Map.empty(), cache)
+    let cache = ModuleCache.new(0)
+    let handler = Handler(
+        fireflyPath = fireflyPath
+        rootPath = None
+        virtualFiles = Map.new()
+        cancelledRequests = [].toSet()
+        responseCache = Map.new()
+        fileSymbolsCache = Map.new()
+        moduleCache = cache
+        dependencyLock = DependencyLock.new(system.mainTask())
+    )
     try {
         mutable input = system.readStream()
         let responseChannel: Channel[Pair[Json, String]] = system.mainTask().channel()
@@ -115,7 +125,7 @@ parseRequest(system: NodeSystem, input: Stream[Buffer]): Pair[Request, Stream[Bu
 }
 
 parseRequestHeaders(input: Stream[Buffer]): Pair[Map[String, String], Stream[Buffer]] {
-    let buffers = Array.make()
+    let buffers = Array.new()
     mutable buffer = input.next().else {
         throw(BadRequestException("End of input while parsing request headers"))
     }

package/lsp/SymbolHandler.ff

@@ -145,9 +145,9 @@ symbolFilter(symbol: WorkspaceSymbol, query: String): Bool {
 }
 
 matchSymbol(symbolWords: List[String], query: String): Bool {
-    let memo = IntMap.make()
+    let memo = IntMap.new()
     function go(wordIndex: Int, queryOffset: Int): Bool {
-        memo.getOrSet(wordIndex) {IntMap.make()}.getOrSet(queryOffset):
+        memo.getOrSet(wordIndex) {IntMap.new()}.getOrSet(queryOffset):
         if(queryOffset >= query.size()) {True} else:
         if(wordIndex >= symbolWords.size()) {False} else:
         prefixes(query.dropFirst(queryOffset)).any {prefix => 

package/lsp/TestReferences.ff

@@ -6,8 +6,8 @@ nodeMain(system: NodeSystem) {
     Log.debug("Hello")
     let fireflyPath = system.path(".")
     Log.debug(fireflyPath.absolute())
-    let cache = ModuleCache.empty(0)
-    let handler = Handler(fireflyPath, None, Map.empty(), [].toSet(), Map.empty(), Map.empty(), cache)
+    let cache = ModuleCache.new(0)
+    let handler = Handler(fireflyPath, None, Map.new(), [].toSet(), Map.new(), Map.new(), cache)
     let targetAt = Location("/home/werk/projects/firefly-boot/lsp/TestReferencesCase.ff", 7, 5)
     let references = handler.findReferences(system, targetAt, local = False, includeDeclaration = True, version = 0)
     Log.show(references)

package/lux/Lux.ff

@@ -138,7 +138,7 @@ extend self: Lux {
 
     set(attribute: String, value: String) {
         let attributes = self.attributes.else {
-            let map = StringMap.make()
+            let map = StringMap.new()
             self.attributes = Some(map)
             map
         }
@@ -153,7 +153,7 @@ extend self: Lux {
     
     css(style: Css) {
         let attributes = self.attributes.else {
-            let map = StringMap.make()
+            let map = StringMap.new()
             self.attributes = Some(map)
             map
         }
@@ -294,7 +294,7 @@ extend self: Lux {
             let lux = luxCopy.Lux(
                 task = task
                 renderLock = task.lock()
-                renderQueue = Array.make()
+                renderQueue = Array.new()
                 element = luxCopy.element.LuxElement(element = fragment)
             )
             try {
@@ -403,7 +403,7 @@ patchElement(self: Lux, tagName: String): JsValue {
     } else {
         let newNode = if(newKey == "") {self.document.createElement(tagName)} else {
             let keys = self.keys.else {
-                let map = StringMap.make()
+                let map = StringMap.new()
                 mutable i = self.element.child
                 mutable c = self.element.childAt(i)
                 while {!c.isNullOrUndefined()} {
@@ -466,7 +466,7 @@ render(browserSystem: BrowserSystem, element: JsValue, body: Lux => Unit) {
     let lux = Lux(
         jsSystem = browserSystem.js()
         renderLock = browserSystem.mainTask().lock()
-        cssClasses = StringMap.make()
+        cssClasses = StringMap.new()
         task = browserSystem.mainTask()
         depth = 0
         document = LuxDocument(document)
@@ -474,7 +474,7 @@ render(browserSystem: BrowserSystem, element: JsValue, body: Lux => Unit) {
         keys = None
         key = ""
         attributes = None
-        renderQueue = Array.make()
+        renderQueue = Array.new()
     )
     lux.renderLock.do(reentrant = False) {
         body(lux)

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

@@ -6,6 +6,8 @@ import * as ff_compiler_Compiler from "../../ff/compiler/Compiler.mjs"
 
 import * as ff_compiler_Dependencies from "../../ff/compiler/Dependencies.mjs"
 
+import * as ff_compiler_DependencyLock from "../../ff/compiler/DependencyLock.mjs"
+
 import * as ff_compiler_JsEmitter from "../../ff/compiler/JsEmitter.mjs"
 
 import * as ff_compiler_LspHook from "../../ff/compiler/LspHook.mjs"
@@ -125,7 +127,7 @@ ff_core_Path.Path_createDirectory(tempPath_, false);
 const jsPathFile_ = ff_core_Path.Path_slash(tempPath_, "js");
 ff_core_Path.Path_createDirectory(jsPathFile_, true);
 const success_ = ff_core_Core.do_((() => {
-const compiler_ = ff_compiler_Compiler.make_(emitTarget_, ff_core_NodeSystem.NodeSystem_mainTask(system_), compilerModulePath_, jsPathFile_, resolvedDependencies_, ff_core_Map.empty_(), moduleCache_, ff_compiler_LspHook.disabled_());
+const compiler_ = ff_compiler_Compiler.new_(emitTarget_, ff_core_NodeSystem.NodeSystem_mainTask(system_), compilerModulePath_, jsPathFile_, resolvedDependencies_, ff_core_Map.new_(), moduleCache_, ff_compiler_LspHook.disabled_());
 ff_compiler_Compiler.Compiler_emit(compiler_, mainPackage_, mainModule_, true);
 if(printMeasurements_) {
 ff_compiler_Compiler.Compiler_printMeasurements(compiler_)
@@ -154,7 +156,7 @@ ff_core_Path.Path_copyTo(fromPath_, toPath_, 0, 100)
 }
 
 export function buildViaBuildSystem_(system_, fireflyPath_, mainFile_, target_) {
-const resolvedDependencies_ = ff_compiler_Dependencies.process_(ff_core_NodeSystem.NodeSystem_httpClient(system_), ff_core_NodeSystem.NodeSystem_path(system_, mainFile_));
+const resolvedDependencies_ = ff_compiler_Dependencies.process_(ff_core_NodeSystem.NodeSystem_httpClient(system_), ff_compiler_DependencyLock.new_(ff_core_NodeSystem.NodeSystem_mainTask(system_)), ff_core_NodeSystem.NodeSystem_path(system_, mainFile_));
 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));
@@ -163,10 +165,10 @@ ff_core_Core.panic_("buildViaBuildSystem is currently limited to browser target
 };
 ff_compiler_Builder.build_(system_, ff_compiler_JsEmitter.EmitBrowser(), resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(mainFile_, ff_core_String.String_size(".ff")), (((_c) => {
 return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.packages_, fixedPackagePaths_, _c.singleFilePackages_)
-}))(resolvedDependencies_), ff_core_Option.None(), ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/temporary"), ff_core_Path.Path_slash(ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/output"), target_), false, ff_compiler_ModuleCache.empty_(0))
+}))(resolvedDependencies_), ff_core_Option.None(), ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/temporary"), ff_core_Path.Path_slash(ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/output"), target_), false, ff_compiler_ModuleCache.new_(0))
 }
 
-export function check_(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, newVersion_, lspHook_, infer_, checkDependencies_) {
+export function check_(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, dependencyLock_, newVersion_, lspHook_, infer_, checkDependencies_) {
 const packages_ = (((_1) => {
 if(_1) {
 return ff_compiler_Builder.findPackageFiles_(path_, mustContain_, skipFiles_)
@@ -178,12 +180,12 @@ if(!_1) {
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab(ff_core_Path.Path_parent(path_)), ff_core_Option.None(), [path_])]
 }
 }))(ff_core_Path.Path_isDirectory(path_));
-const errors_ = ff_core_Array.make_();
+const errors_ = ff_core_Array.new_();
 ff_core_List.List_each(ff_core_List.List_filter(packages_, ((_w1) => {
 return (!ff_core_List.List_isEmpty(_w1.files_))
 })), ((package_) => {
 const firstFile_ = ff_core_List.List_grabFirst(package_.files_);
-const resolvedDependencies_ = ff_compiler_Dependencies.process_(ff_core_NodeSystem.NodeSystem_httpClient(system_), firstFile_);
+const resolvedDependencies_ = ff_compiler_Dependencies.process_(ff_core_NodeSystem.NodeSystem_httpClient(system_), dependencyLock_, firstFile_);
 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));
@@ -191,7 +193,7 @@ const fixedResolvedDependencies_ = (((_c) => {
 return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.packages_, fixedPackagePaths_, _c.singleFilePackages_)
 }))(resolvedDependencies_);
 const newCache_ = ff_compiler_ModuleCache.ModuleCache_without(cache_, newVersion_, path_);
-const compiler_ = ff_compiler_Compiler.make_(ff_compiler_JsEmitter.EmitBuild(), ff_core_NodeSystem.NodeSystem_mainTask(system_), ff_core_Option.None(), ff_core_Path.Path_slash(ff_core_Path.Path_slash(package_.root_, ".firefly"), "temporary"), fixedResolvedDependencies_, virtualFiles_, newCache_, lspHook_);
+const compiler_ = ff_compiler_Compiler.new_(ff_compiler_JsEmitter.EmitBuild(), ff_core_NodeSystem.NodeSystem_mainTask(system_), ff_core_Option.None(), ff_core_Path.Path_slash(ff_core_Path.Path_slash(package_.root_, ".firefly"), "temporary"), fixedResolvedDependencies_, virtualFiles_, newCache_, lspHook_);
 const files_ = (checkDependencies_
 ? package_.files_
 : ff_core_List.List_filter(package_.files_, ((_w1) => {
@@ -199,22 +201,27 @@ return (!ff_core_Path.Path_contains(_w1, [".firefly", "dependencies"]))
 })));
 ff_core_List.List_each(files_, ((file_) => {
 const localFile_ = ff_core_Path.Path_base(file_);
-try {
+ff_core_Try.Try_grab(ff_core_Try.Try_catch(ff_core_Try.Try_catch(ff_core_Core.try_((() => {
 if(infer_) {
 ff_compiler_Compiler.Compiler_infer(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ff_core_String.String_size(".ff")))
 } else {
 ff_compiler_Compiler.Compiler_resolve(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ff_core_String.String_size(".ff")))
 }
-} catch(_error) {
-if(!_error.ffException) throw _error
-const _exception = ff_core_Any.fromAny_(_error.ffException, ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)
-if(!_exception.Some) throw _error
+})), ((_1, _2) => {
 {
-const c_ = _exception.value_;
-const error_ = _error;
+const c_ = _1;
+const error_ = _2;
 ff_core_Array.Array_push(errors_, c_)
+return
 }
+}), 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_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors))
 }));
 ff_compiler_ModuleCache.ModuleCache_mergeVersions(cache_, compiler_.cache_)
 }));
@@ -314,7 +321,7 @@ if((await ff_core_Path.Path_exists$(tempPath_, false, false, false, $task))) {
 const jsPathFile_ = (await ff_core_Path.Path_slash$(tempPath_, "js", $task));
 (await ff_core_Path.Path_createDirectory$(jsPathFile_, true, $task));
 const success_ = (await ff_core_Core.do_$((async ($task) => {
-const compiler_ = (await ff_compiler_Compiler.make_$(emitTarget_, (await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), compilerModulePath_, jsPathFile_, resolvedDependencies_, ff_core_Map.empty_(), moduleCache_, ff_compiler_LspHook.disabled_(), $task));
+const compiler_ = (await ff_compiler_Compiler.new_$(emitTarget_, (await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), compilerModulePath_, jsPathFile_, resolvedDependencies_, ff_core_Map.new_(), moduleCache_, ff_compiler_LspHook.disabled_(), $task));
 (await ff_compiler_Compiler.Compiler_emit$(compiler_, mainPackage_, mainModule_, true, $task));
 if(printMeasurements_) {
 (await ff_compiler_Compiler.Compiler_printMeasurements$(compiler_, $task))
@@ -343,7 +350,7 @@ const toPath_ = (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(
 }
 
 export async function buildViaBuildSystem_$(system_, fireflyPath_, mainFile_, target_, $task) {
-const resolvedDependencies_ = (await ff_compiler_Dependencies.process_$((await ff_core_NodeSystem.NodeSystem_httpClient$(system_, $task)), (await ff_core_NodeSystem.NodeSystem_path$(system_, mainFile_, $task)), $task));
+const resolvedDependencies_ = (await ff_compiler_Dependencies.process_$((await ff_core_NodeSystem.NodeSystem_httpClient$(system_, $task)), (await ff_compiler_DependencyLock.new_$((await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), $task)), (await ff_core_NodeSystem.NodeSystem_path$(system_, mainFile_, $task)), $task));
 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));
@@ -352,10 +359,10 @@ ff_core_Core.panic_("buildViaBuildSystem is currently limited to browser target
 };
 (await ff_compiler_Builder.build_$(system_, ff_compiler_JsEmitter.EmitBrowser(), resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(mainFile_, ff_core_String.String_size(".ff")), (((_c) => {
 return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.packages_, fixedPackagePaths_, _c.singleFilePackages_)
-}))(resolvedDependencies_), ff_core_Option.None(), (await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/temporary", $task)), (await ff_core_Path.Path_slash$((await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/output", $task)), target_, $task)), false, ff_compiler_ModuleCache.empty_(0), $task))
+}))(resolvedDependencies_), ff_core_Option.None(), (await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/temporary", $task)), (await ff_core_Path.Path_slash$((await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/output", $task)), target_, $task)), false, ff_compiler_ModuleCache.new_(0), $task))
 }
 
-export async function check_$(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, newVersion_, lspHook_, infer_, checkDependencies_, $task) {
+export async function check_$(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, dependencyLock_, newVersion_, lspHook_, infer_, checkDependencies_, $task) {
 const packages_ = (await ((async (_1, $task) => {
 if(_1) {
 return (await ff_compiler_Builder.findPackageFiles_$(path_, mustContain_, skipFiles_, $task))
@@ -367,12 +374,12 @@ if(!_1) {
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(path_, $task))), ff_core_Option.None(), [path_])]
 }
 }))((await ff_core_Path.Path_isDirectory$(path_, $task)), $task));
-const errors_ = ff_core_Array.make_();
+const errors_ = ff_core_Array.new_();
 (await ff_core_List.List_each$(ff_core_List.List_filter(packages_, ((_w1) => {
 return (!ff_core_List.List_isEmpty(_w1.files_))
 })), (async (package_, $task) => {
 const firstFile_ = ff_core_List.List_grabFirst(package_.files_);
-const resolvedDependencies_ = (await ff_compiler_Dependencies.process_$((await ff_core_NodeSystem.NodeSystem_httpClient$(system_, $task)), firstFile_, $task));
+const resolvedDependencies_ = (await ff_compiler_Dependencies.process_$((await ff_core_NodeSystem.NodeSystem_httpClient$(system_, $task)), dependencyLock_, firstFile_, $task));
 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));
@@ -380,7 +387,7 @@ const fixedResolvedDependencies_ = (((_c) => {
 return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.packages_, fixedPackagePaths_, _c.singleFilePackages_)
 }))(resolvedDependencies_);
 const newCache_ = (await ff_compiler_ModuleCache.ModuleCache_without$(cache_, newVersion_, path_, $task));
-const compiler_ = (await ff_compiler_Compiler.make_$(ff_compiler_JsEmitter.EmitBuild(), (await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), ff_core_Option.None(), (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(package_.root_, ".firefly", $task)), "temporary", $task)), fixedResolvedDependencies_, virtualFiles_, newCache_, lspHook_, $task));
+const compiler_ = (await ff_compiler_Compiler.new_$(ff_compiler_JsEmitter.EmitBuild(), (await ff_core_NodeSystem.NodeSystem_mainTask$(system_, $task)), ff_core_Option.None(), (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(package_.root_, ".firefly", $task)), "temporary", $task)), fixedResolvedDependencies_, virtualFiles_, newCache_, lspHook_, $task));
 const files_ = (checkDependencies_
 ? package_.files_
 : (await ff_core_List.List_filter$(package_.files_, (async (_w1, $task) => {
@@ -388,22 +395,27 @@ return (!(await ff_core_Path.Path_contains$(_w1, [".firefly", "dependencies"], $
 }), $task)));
 (await ff_core_List.List_each$(files_, (async (file_, $task) => {
 const localFile_ = (await ff_core_Path.Path_base$(file_, $task));
-try {
+ff_core_Try.Try_grab(ff_core_Try.Try_catch(ff_core_Try.Try_catch((await ff_core_Core.try_$((async ($task) => {
 if(infer_) {
 (await ff_compiler_Compiler.Compiler_infer$(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ff_core_String.String_size(".ff")), $task))
 } else {
 (await ff_compiler_Compiler.Compiler_resolve$(compiler_, resolvedDependencies_.mainPackagePair_, ff_core_String.String_dropLast(localFile_, ff_core_String.String_size(".ff")), $task))
 }
-} catch(_error) {
-if(!_error.ffException) throw _error
-const _exception = ff_core_Any.fromAny_(_error.ffException, ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)
-if(!_exception.Some) throw _error
+}), $task)), ((_1, _2) => {
 {
-const c_ = _exception.value_;
-const error_ = _error;
+const c_ = _1;
+const error_ = _2;
 ff_core_Array.Array_push(errors_, c_)
+return
 }
+}), 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_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors))
 }), $task));
 ff_compiler_ModuleCache.ModuleCache_mergeVersions(cache_, compiler_.cache_)
 }), $task));