firefly-compiler 0.4.50 → 0.4.52

package/compiler/Compiler.ff

@@ -1,227 +1,227 @@
-import Syntax
-import Tokenizer
-import ModuleCache
-import Parser
-import Resolver
-import Deriver
-import Inference
-import JsEmitter
-import Dictionaries
-import Dependencies
-import LspHook
-
-capability Compiler(
-    emitTarget: EmitTarget
-    task: Task
-    compilerModulePath: Option[Path]
-    jsOutputPath: Path
-    packagePaths: Map[PackagePair, Path]
-    singleFilePackages: Set[PackagePair]
-    virtualFiles: Map[String, String]
-    cache: ModuleCache
-    lspHook: LspHook
-    mutable phaseDurationDelta: Duration
-    phaseDurations: Array[Pair[String, Duration]]
-)
-
-new(
-    emitTarget: EmitTarget
-    task: Task
-    compilerModulePath: Option[Path]
-    jsOutputPath: Path
-    resolvedDependencies: ResolvedDependencies
-    virtualFiles: Map[String, String]
-    cache: ModuleCache
-    lspHook: LspHook
-): Compiler {
-    Compiler(
-        emitTarget = emitTarget
-        task = task
-        compilerModulePath = compilerModulePath
-        jsOutputPath = jsOutputPath
-        packagePaths = resolvedDependencies.packagePaths
-        singleFilePackages = resolvedDependencies.singleFilePackages
-        virtualFiles = virtualFiles
-        cache = cache
-        lspHook = lspHook
-        phaseDurationDelta = Duration(0.0)
-        phaseDurations = [].toArray()
-    )
-}
-
-fail[T](at: Location, message: String): T {
-    panic(message + " " + at.show())
-}
-
-coreImports: List[DImport] =
-    [
-        "Any"
-        "Array"
-        "AssetSystem"
-        "Atomic"
-        "Bool"
-        "BrowserSystem"
-        "Buffer"
-        "BuildSystem"
-        "Channel"
-        "Char"
-        "Core"
-        "Crypto"
-        "Duration"
-        "Equal"
-        "Error"
-        "FileHandle"
-        "Float"
-        "HttpClient"
-        "Instant"
-        "Int"
-        "IntMap"
-        "Json"
-        "JsValue"
-        "JsSystem"
-        "List"
-        "Lock"
-        "Log"
-        "Map"
-        "NodeSystem"
-        "Nothing"
-        "Option"
-        "Ordering"
-        "Pair"
-        "Path"
-        "Random"
-        "Serializable"
-        "Set"
-        "Show"
-        "SourceLocation"
-        "Stream"
-        "String"
-        "StringMap"
-        "Task"
-        "Try"
-        "Unit"
-    ].map {moduleName =>
-        DImport(
-            at = Location("<prelude>", 1, 1)
-            alias = moduleName
-            package = PackagePair("ff", "core")
-            directory = []
-            file = moduleName
-        )
-    }
-
-extend self: Compiler {
-
-    measure[T](phase: String, packagePair: PackagePair, moduleName: String, body: () => T): T {
-        let start = Duration(self.task.elapsed().seconds - self.phaseDurationDelta.seconds)
-        let result = body()
-        let stop = Duration(self.task.elapsed().seconds - self.phaseDurationDelta.seconds)
-        let duration = Duration(stop.seconds - start.seconds)
-        self.phaseDurationDelta = Duration(self.phaseDurationDelta.seconds + duration.seconds)
-        let text = phase + " " + packagePair.groupName() + "/" + moduleName
-        self.phaseDurations.push(Pair(text, duration))
-        result
-    }
-
-    printMeasurements(): Unit {
-        let worst = self.phaseDurations.toList().sortBy {
-            (_.second.seconds + 1000000.0) + ""
-        }.takeLast(5).reverse()
-        worst.each {| Pair(text, duration) =>
-            Log.debug(text + ":\t" + duration.show())
-        }
-    }
-
-    parse(packagePair: PackagePair, moduleName: String, importedAt: Option[Location]): Module {
-        self.cache.cacheParsedModule(self.packagePaths, packagePair, moduleName): path => 
-        let packageName = packagePair.groupName()
-        self.measure("Parse", packagePair, moduleName):
-        let code = self.virtualFiles.get(path.absolute()).else {
-            importedAt.each {at => if(!path.exists()) {
-                throw(CompileError(at, "Imported module not found: " + packageName + "/" + moduleName))
-            }}
-            path.readText()
-        }
-        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.new(packagePair, path.base(), tokens, self.emitTarget != EmitBrowser, self.lspHook)
-        let module = if(self.singleFilePackages.contains(packagePair)) {
-            parser.parseModuleWithPackageInfo().module
-        } else {
-            parser.parseModuleWithoutPackageInfo()
-        }
-        let result = module.Module(
-            imports = [...coreImports, ...module.imports]
-        )
-        result
-    }
-
-    imports(module: Module): List[Module] {
-        module.imports.map {import =>
-            let newPackagePair = import.package
-            let newModuleName = import.directory.map {_ + "/"}.join("") + import.file
-            if(!self.packagePaths.contains(newPackagePair)) {
-                throw(CompileError(import.at, "Missing dependency declaration for: " + newPackagePair.groupName()))
-            }
-            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()
-        }
-    }
-
-    resolve(packagePair: PackagePair, moduleName: String): Module {
-        self.cache.cacheResolvedModule(self.packagePaths, packagePair, moduleName): path => 
-        self.measure("Resolve", packagePair, moduleName):
-
-        let module = self.parse(packagePair, moduleName, None)
-        let otherModules = self.imports(module)
-        let resolver = Resolver.new(packagePair, moduleName, self.lspHook)
-        resolver.resolveModule(module, otherModules)
-    }
-
-    derive(packagePair: PackagePair, moduleName: String): Module {
-        self.cache.cacheDerivedModule(self.packagePaths, packagePair, moduleName): path => 
-        self.measure("Derive", packagePair, moduleName):
-
-        let module = self.resolve(packagePair, moduleName)
-        Deriver.new().deriveModule(module)
-    }
-
-    infer(packagePair: PackagePair, moduleName: String): Module {
-        self.cache.cacheInferredModule(self.packagePaths, packagePair, moduleName): path => 
-        self.measure("Infer", packagePair, moduleName):
-
-        let module = self.derive(packagePair, moduleName)
-        let otherModules = self.imports(module).map {i =>
-            self.derive(i.packagePair, i.file.dropLast(".ff".size()))
-        }
-        let inference = Inference.new([module, ...otherModules], self.lspHook)
-        let inferredModule = inference.inferModule(module, otherModules)
-        Dictionaries.new([module, ...otherModules]).processModule(inferredModule, otherModules)
-    }
-
-    emit(packagePair: PackagePair, moduleName: String, isMainModule: Bool): Unit {
-        self.cache.cacheEmittedModule(self.packagePaths, packagePair, moduleName): path => 
-        self.measure("Emit", packagePair, moduleName):
-
-        let module = self.infer(packagePair, moduleName)
-        let otherModules = self.imports(module).map {i =>
-            let newModuleName = i.file.dropLast(".ff".size())
-            self.emit(i.packagePair, newModuleName, isMainModule = False)
-            self.infer(i.packagePair, newModuleName)
-        }
-
-        let allModules = [module, ...otherModules]
-        let js = 
-            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")
-        jsPath.createDirectory(createParentDirectories = True)
-        jsFile.writeText(js)
-    }
-
-}
+import Syntax
+import Tokenizer
+import ModuleCache
+import Parser
+import Resolver
+import Deriver
+import Inference
+import JsEmitter
+import Dictionaries
+import Dependencies
+import LspHook
+
+capability Compiler(
+    emitTarget: EmitTarget
+    task: Task
+    compilerModulePath: Option[Path]
+    jsOutputPath: Path
+    packagePaths: Map[PackagePair, Path]
+    singleFilePackages: Set[PackagePair]
+    virtualFiles: Map[String, String]
+    cache: ModuleCache
+    lspHook: LspHook
+    mutable phaseDurationDelta: Duration
+    phaseDurations: Array[Pair[String, Duration]]
+)
+
+new(
+    emitTarget: EmitTarget
+    task: Task
+    compilerModulePath: Option[Path]
+    jsOutputPath: Path
+    resolvedDependencies: ResolvedDependencies
+    virtualFiles: Map[String, String]
+    cache: ModuleCache
+    lspHook: LspHook
+): Compiler {
+    Compiler(
+        emitTarget = emitTarget
+        task = task
+        compilerModulePath = compilerModulePath
+        jsOutputPath = jsOutputPath
+        packagePaths = resolvedDependencies.packagePaths
+        singleFilePackages = resolvedDependencies.singleFilePackages
+        virtualFiles = virtualFiles
+        cache = cache
+        lspHook = lspHook
+        phaseDurationDelta = Duration(0.0)
+        phaseDurations = [].toArray()
+    )
+}
+
+fail[T](at: Location, message: String): T {
+    panic(message + " " + at.show())
+}
+
+coreImports: List[DImport] =
+    [
+        "Any"
+        "Array"
+        "AssetSystem"
+        "Atomic"
+        "Bool"
+        "BrowserSystem"
+        "Buffer"
+        "BuildSystem"
+        "Channel"
+        "Char"
+        "Core"
+        "Crypto"
+        "Duration"
+        "Equal"
+        "Error"
+        "FileHandle"
+        "Float"
+        "HttpClient"
+        "Instant"
+        "Int"
+        "IntMap"
+        "Json"
+        "JsValue"
+        "JsSystem"
+        "List"
+        "Lock"
+        "Log"
+        "Map"
+        "NodeSystem"
+        "Nothing"
+        "Option"
+        "Ordering"
+        "Pair"
+        "Path"
+        "Random"
+        "Serializable"
+        "Set"
+        "Show"
+        "SourceLocation"
+        "Stream"
+        "String"
+        "StringMap"
+        "Task"
+        "Try"
+        "Unit"
+    ].map {moduleName =>
+        DImport(
+            at = Location("<prelude>", 1, 1)
+            alias = moduleName
+            package = PackagePair("ff", "core")
+            directory = []
+            file = moduleName
+        )
+    }
+
+extend self: Compiler {
+
+    measure[T](phase: String, packagePair: PackagePair, moduleName: String, body: () => T): T {
+        let start = Duration(self.task.elapsed().seconds - self.phaseDurationDelta.seconds)
+        let result = body()
+        let stop = Duration(self.task.elapsed().seconds - self.phaseDurationDelta.seconds)
+        let duration = Duration(stop.seconds - start.seconds)
+        self.phaseDurationDelta = Duration(self.phaseDurationDelta.seconds + duration.seconds)
+        let text = phase + " " + packagePair.groupName() + "/" + moduleName
+        self.phaseDurations.push(Pair(text, duration))
+        result
+    }
+
+    printMeasurements(): Unit {
+        let worst = self.phaseDurations.toList().sortBy {
+            (_.second.seconds + 1000000.0) + ""
+        }.takeLast(5).reverse()
+        worst.each {| Pair(text, duration) =>
+            Log.debug(text + ":\t" + duration.show())
+        }
+    }
+
+    parse(packagePair: PackagePair, moduleName: String, importedAt: Option[Location]): Module {
+        self.cache.cacheParsedModule(self.packagePaths, packagePair, moduleName): path => 
+        let packageName = packagePair.groupName()
+        self.measure("Parse", packagePair, moduleName):
+        let code = self.virtualFiles.get(path.absolute()).else {
+            importedAt.each {at => if(!path.exists()) {
+                throw(CompileError(at, "Imported module not found: " + packageName + "/" + moduleName))
+            }}
+            path.readText()
+        }
+        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.new(packagePair, path.base(), tokens, self.emitTarget != EmitBrowser, self.lspHook)
+        let module = if(self.singleFilePackages.contains(packagePair)) {
+            parser.parseModuleWithPackageInfo().module
+        } else {
+            parser.parseModuleWithoutPackageInfo()
+        }
+        let result = module.Module(
+            imports = [...coreImports, ...module.imports]
+        )
+        result
+    }
+
+    imports(module: Module): List[Module] {
+        module.imports.map {import =>
+            let newPackagePair = import.package
+            let newModuleName = import.directory.map {_ + "/"}.join("") + import.file
+            if(!self.packagePaths.contains(newPackagePair)) {
+                throw(CompileError(import.at, "Missing dependency declaration for: " + newPackagePair.groupName()))
+            }
+            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()
+        }
+    }
+
+    resolve(packagePair: PackagePair, moduleName: String): Module {
+        self.cache.cacheResolvedModule(self.packagePaths, packagePair, moduleName): path => 
+        self.measure("Resolve", packagePair, moduleName):
+
+        let module = self.parse(packagePair, moduleName, None)
+        let otherModules = self.imports(module)
+        let resolver = Resolver.new(packagePair, moduleName, self.lspHook)
+        resolver.resolveModule(module, otherModules)
+    }
+
+    derive(packagePair: PackagePair, moduleName: String): Module {
+        self.cache.cacheDerivedModule(self.packagePaths, packagePair, moduleName): path => 
+        self.measure("Derive", packagePair, moduleName):
+
+        let module = self.resolve(packagePair, moduleName)
+        Deriver.new().deriveModule(module)
+    }
+
+    infer(packagePair: PackagePair, moduleName: String): Module {
+        self.cache.cacheInferredModule(self.packagePaths, packagePair, moduleName): path => 
+        self.measure("Infer", packagePair, moduleName):
+
+        let module = self.derive(packagePair, moduleName)
+        let otherModules = self.imports(module).map {i =>
+            self.derive(i.packagePair, i.file.dropLast(".ff".size()))
+        }
+        let inference = Inference.new([module, ...otherModules], self.lspHook)
+        let inferredModule = inference.inferModule(module, otherModules)
+        Dictionaries.new([module, ...otherModules]).processModule(inferredModule, otherModules)
+    }
+
+    emit(packagePair: PackagePair, moduleName: String, isMainModule: Bool): Unit {
+        self.cache.cacheEmittedModule(self.packagePaths, packagePair, moduleName): path => 
+        self.measure("Emit", packagePair, moduleName):
+
+        let module = self.infer(packagePair, moduleName)
+        let otherModules = self.imports(module).map {i =>
+            let newModuleName = i.file.dropLast(".ff".size())
+            self.emit(i.packagePair, newModuleName, isMainModule = False)
+            self.infer(i.packagePair, newModuleName)
+        }
+
+        let allModules = [module, ...otherModules]
+        let js = 
+            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")
+        jsPath.createDirectory(createParentDirectories = True)
+        jsFile.writeText(js)
+    }
+
+}