firefly-compiler 0.4.31 → 0.4.32

package/bin/Release.ff

@@ -0,0 +1,6 @@
+nodeMain(system: NodeSystem) {
+    let result = system.execute("npm", ["-v"])
+    Log.trace("exitCode: " + result.exitCode)
+    Log.trace("out: " + result.standardOut.toString())
+    Log.trace("err: " + result.standardError.toString())
+}

package/compiler/Builder.ff

@@ -8,6 +8,7 @@ import Dependencies
 import JsEmitter
 import ModuleCache
 import LspHook
+import DependencyLock
 
 build(
     system: NodeSystem
@@ -29,13 +30,13 @@ build(
     jsPathFile.createDirectory(createParentDirectories = True)
 
     let success = do {
-        let compiler = Compiler.make(
+        let compiler = Compiler.new(
             emitTarget
             system.mainTask()
             compilerModulePath
             jsPathFile
             resolvedDependencies
-            Map.empty()
+            Map.new()
             moduleCache
             lspHook = LspHook.disabled()
         )
@@ -65,7 +66,11 @@ processIncludes(jsPathFile: Path, packagePath: Path, info: PackageInfo): Unit {
 }
 
 buildViaBuildSystem(system: NodeSystem, fireflyPath: Path, mainFile: String, target: String) {
-    let resolvedDependencies = Dependencies.process(system.httpClient(), system.path(mainFile))
+    let resolvedDependencies = Dependencies.process(
+        system.httpClient()
+        DependencyLock.new(system.mainTask())
+        system.path(mainFile)
+    )
     let fixedPackagePaths = if(resolvedDependencies.packagePaths.contains(PackagePair("ff", "core"))) {
         resolvedDependencies.packagePaths
     } else {
@@ -84,7 +89,7 @@ buildViaBuildSystem(system: NodeSystem, fireflyPath: Path, mainFile: String, tar
         tempPath = system.path(".firefly/temporary")
         jsOutputPath = system.path(".firefly/output").slash(target)
         printMeasurements = False
-        moduleCache = ModuleCache.empty(0)
+        moduleCache = ModuleCache.new(0)
     )
 }
 
@@ -96,6 +101,7 @@ check(
     skipFiles: Set[String]
     virtualFiles: Map[String, String]
     cache: ModuleCache
+    dependencyLock: DependencyLock
     newVersion: Int
     lspHook: LspHook
     infer: Bool
@@ -106,11 +112,11 @@ check(
         | False {path.endsWith([".firefly", "package.ff"])} => [PackageFiles(path.parent().grab(), Some(path), [])]
         | False => [PackageFiles(path.parent().grab(), None, [path])]
     }
-    let errors = Array.make()
+    let errors = Array.new()
 
     packages.filter {!_.files.isEmpty()}.each {package => 
         let firstFile = package.files.grabFirst()
-        let resolvedDependencies = Dependencies.process(system.httpClient(), firstFile)
+        let resolvedDependencies = Dependencies.process(system.httpClient(), dependencyLock, firstFile)
         let fixedPackagePaths = if(resolvedDependencies.packagePaths.contains(PackagePair("ff", "core"))) {
             resolvedDependencies.packagePaths
         } else {
@@ -118,7 +124,7 @@ check(
         }
         let fixedResolvedDependencies = resolvedDependencies.ResolvedDependencies(packagePaths = fixedPackagePaths)
         let newCache = cache.without(newVersion, path)
-        let compiler = Compiler.make(
+        let compiler = Compiler.new(
             EmitBuild
             system.mainTask() 
             None
@@ -141,6 +147,8 @@ check(
                 }
             } catch {| CompileError(_, _) @ c, error =>
                 errors.push(c)
+            } catch {| CompileErrors(compileErrors), error =>
+                errors.pushList(compileErrors)
             } grab()
         }
         cache.mergeVersions(compiler.cache)

package/compiler/Compiler.ff

@@ -24,7 +24,7 @@ capability Compiler(
     phaseDurations: Array[Pair[String, Duration]]
 )
 
-make(
+new(
     emitTarget: EmitTarget
     task: Task
     compilerModulePath: Option[Path]
@@ -143,7 +143,7 @@ extend self: Compiler {
         }
         let completionAt = if(self.lspHook.isEnabled() && self.lspHook.insertIdentifier) {self.lspHook.at}
         let tokens = Tokenizer.tokenize(path.absolute(), code, completionAt, self.lspHook.isEnabled())
-        let parser = Parser.make(packagePair, path.base(), tokens, self.emitTarget != EmitBrowser, self.lspHook)
+        let parser = Parser.new(packagePair, path.base(), tokens, self.emitTarget != EmitBrowser, self.lspHook)
         let module = if(self.singleFilePackages.contains(packagePair)) {
             parser.parseModuleWithPackageInfo().module
         } else {
@@ -162,7 +162,12 @@ extend self: Compiler {
             if(!self.packagePaths.contains(newPackagePair)) {
                 throw(CompileError(import.at, "Missing dependency declaration for: " + newPackagePair.groupName()))
             }
-            self.parse(newPackagePair, newModuleName, Some(import.at))
+            try {
+                self.parse(newPackagePair, newModuleName, Some(import.at))
+            } catch {| CompileError(_, _) @ e, error =>
+                let newError = CompileError(import.at, "Parse error in imported module: " + import.package.groupName() + "/" + newModuleName)
+                throw(CompileErrors([e, newError]))
+            } grab()
         }
     }
 
@@ -172,7 +177,7 @@ extend self: Compiler {
 
         let module = self.parse(packagePair, moduleName, None)
         let otherModules = self.imports(module)
-        let resolver = Resolver.make(packagePair, moduleName, self.lspHook)
+        let resolver = Resolver.new(packagePair, moduleName, self.lspHook)
         resolver.resolveModule(module, otherModules)
     }
 
@@ -181,7 +186,7 @@ extend self: Compiler {
         self.measure("Derive", packagePair, moduleName):
 
         let module = self.resolve(packagePair, moduleName)
-        Deriver.make().deriveModule(module)
+        Deriver.new().deriveModule(module)
     }
 
     infer(packagePair: PackagePair, moduleName: String): Module {
@@ -192,9 +197,9 @@ extend self: Compiler {
         let otherModules = self.imports(module).map {i =>
             self.derive(i.packagePair, i.file.dropLast(".ff".size()))
         }
-        let inference = Inference.make([module, ...otherModules], self.lspHook)
+        let inference = Inference.new([module, ...otherModules], self.lspHook)
         let inferredModule = inference.inferModule(module, otherModules)
-        Dictionaries.make([module, ...otherModules]).processModule(inferredModule, otherModules)
+        Dictionaries.new([module, ...otherModules]).processModule(inferredModule, otherModules)
     }
 
     emit(packagePair: PackagePair, moduleName: String, isMainModule: Bool): Unit {
@@ -210,7 +215,7 @@ extend self: Compiler {
 
         let allModules = [module, ...otherModules]
         let js = 
-            JsEmitter.make(allModules, self.emitTarget, isMainModule, self.compilerModulePath, packagePair, moduleName)
+            JsEmitter.new(allModules, self.emitTarget, isMainModule, self.compilerModulePath, packagePair, moduleName)
             .emitModule(packagePair, module)
         let jsPath = self.jsOutputPath.slash(packagePair.group).slash(packagePair.name)
         let jsFile = jsPath.slash(moduleName + ".mjs")

package/compiler/Dependencies.ff

@@ -3,6 +3,7 @@ import Syntax
 import Tokenizer
 import Workspace
 import LspHook
+import DependencyLock
 
 capability Dependencies(
     workspace: Workspace
@@ -42,7 +43,7 @@ extend self: Dependencies {
         code: String
     ): PackageInfo {
         let tokens = Tokenizer.tokenize(fileName, code, None, True)
-        let parser = Parser.make(packagePair, fileName, tokens, False, LspHook.disabled())
+        let parser = Parser.new(packagePair, fileName, tokens, False, LspHook.disabled())
         let info = parser.parsePackageInfo()
         self.addCoreDependencyIfMissing(info)
     }
@@ -74,6 +75,7 @@ extend self: Dependencies {
     fetchDependency(
         path: Path
         httpClient: HttpClient
+        dependencyLock: DependencyLock
         dependency: DDependency
     ): Path {
         let location = self.workspace.findPackageLocation(dependency.packagePair, dependency.version)
@@ -86,19 +88,23 @@ extend self: Dependencies {
                 let tarGzPath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version))
                 let donePath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version) + ".done")
                 if(!donePath.exists()) {
-                    Log.trace("Fetching " + location)
-                    let response = httpClient.fetch(location, throw = False)
-                    if(!response.ok()) {
-                        panic("Could not download dependency: " + location)
+                    dependencyLock.do(donePath.absolute()) {
+                        if(!donePath.exists()) {
+                            Log.trace("Fetching " + location)
+                            let response = httpClient.fetch(location, throw = False)
+                            if(!response.ok()) {
+                                panic("Could not download dependency: " + location)
+                            }
+                            let buffer = response.readBuffer()
+                            if(dependencyPath.exists()) {
+                                dependencyPath.delete()
+                            }
+                            dependencyPath.createDirectory(createParentDirectories = True)
+                            tarGzPath.writeStream([buffer].toStream())
+                            internalExtractTarGz(tarGzPath, dependencyPath)
+                            tarGzPath.renameTo(donePath)
+                        }
                     }
-                    let buffer = response.readBuffer()
-                    if(dependencyPath.exists()) {
-                        dependencyPath.delete()
-                    }
-                    dependencyPath.createDirectory(createParentDirectories = True)
-                    tarGzPath.writeStream([buffer].toStream())
-                    internalExtractTarGz(tarGzPath, dependencyPath)
-                    tarGzPath.renameTo(donePath)
                 }
                 dependencyPath
             } else {
@@ -112,11 +118,12 @@ extend self: Dependencies {
     processDependencies(
         path: Path
         httpClient: HttpClient
+        dependencyLock: DependencyLock
         dependencies: List[DDependency]
     ): Unit {
         // Remember to check for cycles
         let packageInfos = dependencies.map {dependency =>
-            let dependencyPath = self.fetchDependency(path, httpClient, dependency)
+            let dependencyPath = self.fetchDependency(path, httpClient, dependencyLock, dependency)
             self.packagePaths = self.packagePaths.add(dependency.packagePair, dependencyPath)
             let packageInfo = self.loadPackageInfo(dependency.packagePair, dependencyPath)
             checkPackagePairs(dependency.packagePair, packageInfo.package.packagePair)
@@ -124,18 +131,18 @@ extend self: Dependencies {
         }
         let newDependencies = packageInfos.flatMap {self.processPackageInfo(_)}
         if(newDependencies != []) {
-            self.processDependencies(path, httpClient, newDependencies)
+            self.processDependencies(path, httpClient, dependencyLock, newDependencies)
         }
     }
 
 }
 
-process(fetch: HttpClient, path: Path): ResolvedDependencies {
+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 newDependencies = self.processPackageInfo(packageInfo)
-    self.processDependencies(path, fetch, newDependencies)
+    self.processDependencies(path, fetch, dependencyLock, newDependencies)
     let packagePaths = self.packagePaths.add(packageInfo.package.packagePair, findScriptPackageLocation(path))
     ResolvedDependencies(
         mainPackagePair = packageInfo.package.packagePair

package/compiler/DependencyLock.ff

@@ -0,0 +1,17 @@
+capability DependencyLock(
+    doneLocks: StringMap[Lock]
+    task: Task
+)
+
+new(task: Task): DependencyLock {
+    DependencyLock(StringMap.new(), task)
+}
+
+extend self: DependencyLock {
+    do[T](doneFile: String, body: () => T): T {
+        let lock = self.doneLocks.getOrSet(doneFile) {self.task.lock()}
+        lock.do(reentrant = False) {
+            body()
+        }
+    }
+}

package/compiler/Deriver.ff

@@ -2,7 +2,7 @@ import Syntax
 
 data Deriver()
 
-make(): Deriver {
+new(): Deriver {
     Deriver()
 }
 
@@ -33,6 +33,7 @@ extend self: Deriver {
         let coreWhitelist = [
             "ff:core/Serializable.DeserializationChecksumException"
             "ff:core/Core.GrabException"
+            "ff:core/NodeSystem.ProcessException"
             "ff:core/Unit.Unit"
             "ff:core/Pair.Pair"
             "ff:core/Option.Option"

package/compiler/Dictionaries.ff

@@ -6,8 +6,8 @@ data Dictionaries(
     instances: Map[InstanceKey, InstanceValue]
 )
 
-make(modules: List[Module]): Dictionaries {
-    Dictionaries(Unification.make(modules, False).instances)
+new(modules: List[Module]): Dictionaries {
+    Dictionaries(Unification.new(modules, False).instances)
 }
 
 fail[T](at: Location, message: String): T {
@@ -17,7 +17,7 @@ fail[T](at: Location, message: String): T {
 extend self: Dictionaries {
 
     processModule(module: Module, otherModules: List[Module]): Module {
-        let environment = Environment.make(module, otherModules, alreadyFlat = True)
+        let environment = Environment.new(module, otherModules, alreadyFlat = True)
         let functionSignatures = environment.symbols.pairs().collect {
             | Pair(name, s) {!s.isVariable} => Some(Pair(name, s.signature))
             | _ => None
@@ -167,7 +167,7 @@ extend self: Dictionaries {
         constraint: Constraint
     ): Dictionary {
         let instantiationMap = typeParameters.zip(typeArguments).toMap()
-        let unification = Unification.make([], False)
+        let unification = Unification.new([], False)
         let newGenerics = constraint.generics.map {unification.instantiate(instantiationMap, _)}
         newGenerics.grabFirst().{
             | TConstructor firstType =>

package/compiler/Environment.ff

@@ -22,13 +22,13 @@ data Instantiated(
     scheme: Scheme
 )
 
-make(module: Module, otherModules: List[Module], alreadyFlat: Bool): Environment {
+new(module: Module, otherModules: List[Module], alreadyFlat: Bool): Environment {
     let processed = processModule(module, True, alreadyFlat)
     let otherProcessed = otherModules.map {processModule(_, False, False)}
     Environment(
         modulePrefix = fullName(module, "")
-        symbols = processed.symbols.addAll(otherProcessed.map {_.symbols}.foldLeft(Map.empty()) {_.addAll(_)})
-        traits = processed.traits.addAll(otherProcessed.map {_.traits}.foldLeft(Map.empty()) {_.addAll(_)})
+        symbols = processed.symbols.addAll(otherProcessed.map {_.symbols}.foldLeft(Map.new()) {_.addAll(_)})
+        traits = processed.traits.addAll(otherProcessed.map {_.traits}.foldLeft(Map.new()) {_.addAll(_)})
         imports = module.imports.map {i => Pair(i.alias, i)}.toMap()
         effect = TConstructor(Location(module.file, 0, 0), "ff:core/Nothing.Nothing", [])
         selfVariable = None

package/compiler/Inference.ff

@@ -10,10 +10,10 @@ class Inference(
     lspHook: LspHook
 )
 
-make(modules: List[Module], lspHook: LspHook): Inference {
+new(modules: List[Module], lspHook: LspHook): Inference {
     Inference(
-        unification = Unification.make(modules, attemptFixes = lspHook.isEnabled())
-        missing = StringMap.make()
+        unification = Unification.new(modules, attemptFixes = lspHook.isEnabled())
+        missing = StringMap.new()
         lspHook = lspHook
     )
 }
@@ -29,7 +29,7 @@ core(name: String): String {
 extend self: Inference {
 
     inferModule(module: Module, otherModules: List[Module]): Module {
-        let environment = Environment.make(module, otherModules, alreadyFlat = False)
+        let environment = Environment.new(module, otherModules, alreadyFlat = False)
 
         let traits = module.traits.map {self.inferTraitDefinition(environment, _)}
         let instances = module.instances.map {self.inferInstanceDefinition(environment, _)}
@@ -274,7 +274,7 @@ extend self: Inference {
         }
         function literal(coreTypeName: String): Map[String, Pair[Location, Type]] {
             self.unification.unify(pattern.at, expected, TConstructor(pattern.at, core(coreTypeName), []))
-            Map.empty()
+            Map.new()
         }
         pattern.{
             | PString _ =>
@@ -284,7 +284,7 @@ extend self: Inference {
             | PChar _ =>
                 literal("Char")
             | PVariable(at, None) =>
-                Map.empty()
+                Map.new()
             | PVariable(at, Some(name)) =>
                 [Pair(name, Pair(at, expected))].toMap()
             | PAlias(at, pattern, variable) =>
@@ -328,7 +328,7 @@ extend self: Inference {
                 }
                 patterns.zip(instantiated.scheme.signature.parameters).map {| Pair(pattern, parameter) =>
                     self.inferPattern(environment, parameter.valueType, pattern)
-                }.foldLeft(Map.empty[String, Pair[Location, Type]]()) {_.addAll(_)}
+                }.foldLeft(Map.new[String, Pair[Location, Type]]()) {_.addAll(_)}
         }
     }
 

package/compiler/JsEmitter.ff

@@ -21,7 +21,7 @@ data EmitTarget {
     EmitExecutable
 }
 
-make(
+new(
     otherModules: List[Module]
     emitTarget: EmitTarget
     isMainModule: Bool
@@ -34,7 +34,7 @@ make(
             let moduleName = m.packagePair.groupName() + "/" + m.file.dropLast(3)
             Pair(moduleName, m)
         }.toMap()
-        jsImporter = JsImporter.make()
+        jsImporter = JsImporter.new()
         emitTarget = emitTarget
         isMainModule = isMainModule
         compilerModulePath = compilerModulePath

package/compiler/JsImporter.ff

@@ -4,8 +4,8 @@ class JsImporter(
     mutable imports: Map[String, String]
 )
 
-make(): JsImporter {
-    JsImporter(Map.empty())
+new(): JsImporter {
+    JsImporter(Map.new())
 }
 
 fail[T](at: Location, message: String): T {

package/compiler/LspHook.ff

@@ -11,10 +11,10 @@ class LspHook(
 )
 
 disabled(): LspHook {
-    make(None, None, False, False)
+    new(None, None, False, False)
 }
 
-make(at: Option[Location], definedAt: Option[Location], insertIdentifier: Bool, trackSymbols: Bool): LspHook {
+new(at: Option[Location], definedAt: Option[Location], insertIdentifier: Bool, trackSymbols: Bool): LspHook {
     LspHook( // Default dummy values instead of Option[Location] to speed up location hit check
         at = at.else {Location("^lsp", -7, -7)}
         definedAt = definedAt.else {Location("^lsp", -7, -7)}

package/compiler/Main.ff

@@ -10,6 +10,7 @@ import JsEmitter
 import Inference
 import ModuleCache
 import LspHook
+import DependencyLock
 
 data MainCommand {
     BootstrapCommand
@@ -55,13 +56,17 @@ main(system: NodeSystem): Unit {
             tempPath = system.path(".firefly").slash("temporary")
             jsOutputPath = system.path(".firefly").path("output").path(targetName)
             printMeasurements = False
-            moduleCache = ModuleCache.empty(0)
+            moduleCache = ModuleCache.new(0)
         )
     }
 
     function runCommand(command: MainCommand) {
         | RunCommand(mainFile, arguments) =>
-            let resolvedDependencies = Dependencies.process(system.httpClient(), system.path(mainFile + ".ff"))
+            let resolvedDependencies = Dependencies.process(
+                system.httpClient()
+                DependencyLock.new(system.mainTask())
+                system.path(mainFile + ".ff")
+            )
             prepareFireflyDirectory(system.path("."))
             let localMainFile = system.path(mainFile).base()
             buildScript(localMainFile, resolvedDependencies.mainPackagePair, EmitNode, resolvedDependencies)
@@ -71,14 +76,22 @@ main(system: NodeSystem): Unit {
             }
 
         | BrowserCommand(mainFile) =>
-            let resolvedDependencies = Dependencies.process(system.httpClient(), system.path(mainFile + ".ff"))
+            let resolvedDependencies = Dependencies.process(
+                system.httpClient()
+                DependencyLock.new(system.mainTask())
+                system.path(mainFile + ".ff")
+            )
             prepareFireflyDirectory(system.path("."))
             let localMainFile = system.path(mainFile).base()
             buildScript(mainFile, resolvedDependencies.mainPackagePair, EmitBrowser, resolvedDependencies)
             bundleForBrowser(system, resolvedDependencies.mainPackagePair, localMainFile)
 
         | BuildCommand(mainFile) =>
-            let resolvedDependencies = Dependencies.process(system.httpClient(), system.path(mainFile + ".ff"))
+            let resolvedDependencies = Dependencies.process(
+                system.httpClient()
+                DependencyLock.new(system.mainTask())
+                system.path(mainFile + ".ff")
+            )
             prepareFireflyDirectory(system.path("."))
             let localMainFile = system.path(mainFile).base()
             buildScript(localMainFile, resolvedDependencies.mainPackagePair, EmitBuild, resolvedDependencies)
@@ -92,9 +105,10 @@ main(system: NodeSystem): Unit {
                 fireflyPath = fireflyPath
                 path = system.path(filePath)
                 mustContain = None
-                skipFiles = Set.empty()
-                virtualFiles = Map.empty()
-                cache = ModuleCache.empty(1)
+                skipFiles = Set.new()
+                virtualFiles = Map.new()
+                cache = ModuleCache.new(1)
+                dependencyLock = DependencyLock.new(system.mainTask())
                 newVersion = 0
                 lspHook = LspHook.disabled() 
                 infer = True
@@ -127,7 +141,7 @@ main(system: NodeSystem): Unit {
                 tempPath = workingDirectory.slash("output").slash("temporary")
                 jsOutputPath = workingDirectory.slash("output").slash("js")
                 printMeasurements = True
-                moduleCache = ModuleCache.empty(0)
+                moduleCache = ModuleCache.new(0)
             )
     }
 

package/compiler/ModuleCache.ff

@@ -9,14 +9,14 @@ class ModuleCache(
     mutable emittedModules: Map[String, Int]
 )
 
-empty(version: Int): ModuleCache {
+new(version: Int): ModuleCache {
     ModuleCache(
         version = version
-        parsedModules = Map.empty()
-        resolvedModules = Map.empty()
-        derivedModules = Map.empty()
-        inferredModules = Map.empty()
-        emittedModules = Map.empty()
+        parsedModules = Map.new()
+        resolvedModules = Map.new()
+        derivedModules = Map.new()
+        inferredModules = Map.new()
+        emittedModules = Map.new()
     )
 }