firefly-compiler 0.4.79 → 0.4.80

package/compiler/Builder.ff

@@ -1,257 +1,257 @@
-import Tokenizer
-import Parser
-import Syntax
-import Resolver
-import Compiler
-import Unification
-import Dependencies
-import JsEmitter
-import ModuleCache
-import LspHook
-import DependencyLock
-
-build(
-    system: NodeSystem
-    emitTarget: EmitTarget
-    mainPackage: PackagePair
-    mainModule: String
-    resolvedDependencies: ResolvedDependencies
-    compilerModulePath: Option[Path]
-    tempPath: Path
-    jsOutputPath: Path
-    printMeasurements: Bool
-    moduleCache: ModuleCache
-): Unit {
-
-    if(tempPath.exists()) {tempPath.delete()}
-    tempPath.createDirectory()
-
-    let jsPathFile = tempPath.slash("js")
-    jsPathFile.createDirectory(createParentDirectories = True)
-
-    let success = do {
-        let compiler = Compiler.new(
-            emitTarget
-            system.mainTask()
-            compilerModulePath
-            jsPathFile
-            resolvedDependencies
-            Map.new()
-            moduleCache
-            lspHook = LspHook.disabled()
-        )
-        compiler.emit(mainPackage, mainModule, isMainModule = True)
-        if(printMeasurements) {compiler.printMeasurements()}
-        resolvedDependencies.packagePaths.each {packagePair, packagePath =>
-            resolvedDependencies.packages.get(packagePair).each {packageInfo =>
-                processIncludes(jsPathFile, packagePath, packageInfo)
-            }
-        }
-        True
-    }
-
-    if(success) {
-        if(jsOutputPath.exists()) {jsOutputPath.delete()}
-        jsPathFile.renameTo(jsOutputPath)
-    }
-
-}
-
-processIncludes(jsPathFile: Path, packagePath: Path, info: PackageInfo): Unit {
-    info.includes.each {include =>
-        let fromPath = packagePath.slash(".firefly").slash("include").slash(include.path)
-        let toPath = jsPathFile.slash(info.package.packagePair.groupName("/")).slash(include.path)
-        fromPath.copyTo(toPath)
-    }
-}
-
-buildViaBuildSystem(system: NodeSystem, fireflyPath: Path, mainFile: String, target: String) {
-    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 {
-        resolvedDependencies.packagePaths.add(PackagePair("ff", "core"), fireflyPath.slash("core"))
-    }
-    if(target != "browser") {
-        panic("buildViaBuildSystem is currently limited to browser target only - the restriction can be lifted")
-    }
-    build(
-        system = system
-        emitTarget = EmitBrowser
-        mainPackage = resolvedDependencies.mainPackagePair
-        mainModule = mainFile.dropLast(".ff".size())
-        resolvedDependencies = resolvedDependencies.ResolvedDependencies(packagePaths = fixedPackagePaths)
-        compilerModulePath = None
-        tempPath = system.path(".firefly/temporary")
-        jsOutputPath = system.path(".firefly/output").slash(target)
-        printMeasurements = False
-        moduleCache = ModuleCache.new(0)
-    )
-}
-
-check(
-    system: NodeSystem
-    fireflyPath: Path
-    path: Path
-    mustContain: Option[String]
-    skipFiles: Set[String]
-    virtualFiles: Map[String, String]
-    cache: ModuleCache
-    dependencyLock: DependencyLock
-    newVersion: Int
-    lspHook: LspHook
-    infer: Bool
-    checkDependencies: Bool
-): List[CompileError] {
-    let packages = path.isDirectory().{
-        | True => findPackageFiles(path, mustContain, skipFiles)
-        | False {path.endsWith([".firefly", "package.ff"])} => [PackageFiles(path.parent().grab(), Some(path), [])]
-        | False => [PackageFiles(path.parent().grab(), None, [path])]
-    }
-    let errors = Array.new()
-
-    packages.filter {!_.files.isEmpty()}.each {package => 
-        let firstFile = package.files.grabFirst()
-        let resolvedDependencies = Dependencies.process(system.httpClient(), dependencyLock, firstFile)
-        let fixedPackagePaths = if(resolvedDependencies.packagePaths.contains(PackagePair("ff", "core"))) {
-            resolvedDependencies.packagePaths
-        } else {
-            resolvedDependencies.packagePaths.add(PackagePair("ff", "core"), fireflyPath.slash("core"))
-        }
-        let fixedResolvedDependencies = resolvedDependencies.ResolvedDependencies(packagePaths = fixedPackagePaths)
-        let newCache = cache.without(newVersion, path)
-        let compiler = Compiler.new(
-            EmitBuild
-            system.mainTask() 
-            None
-            package.root.slash(".firefly").slash("temporary")
-            fixedResolvedDependencies
-            virtualFiles
-            newCache
-            lspHook
-        )
-        let files = if(checkDependencies) {package.files} else {
-            package.files.filter {!_.contains([".firefly", "dependencies"])}
-        }
-        files.each {file =>
-            let localFile = file.base()
-            try {
-                if(infer) {
-                    compiler.infer(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
-                } else {
-                    compiler.resolve(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
-                }
-            } catch {| CompileError(_, _) @ c, error =>
-                errors.push(c)
-            } catch {| CompileErrors(compileErrors), error =>
-                errors.pushList(compileErrors)
-            } grab()
-        }
-        cache.mergeVersions(compiler.cache)
-    }
-    errors.drain()
-
-}
-
-capability PackageFiles(
-    root: Path
-    packageFile: Option[Path]
-    files: List[Path]
-)
-
-
-findPackageFiles(
-    path: Path
-    mustContain: Option[String]
-    skipFiles: Set[String]
-): List[PackageFiles] {
-    let files = findFireflyFiles(path, mustContain, skipFiles)
-    let split = files.partition {_.endsWith([".firefly", "package.ff"])}
-    let packageFiles = split.first
-    mutable singleFiles = split.second
-    let multiFileProjects = packageFiles.map {packageFile => 
-        let projectRoot = packageFile.parent().grab().parent().grab()
-        let files = singleFiles.partition {_.isInsideOf(projectRoot)}
-        singleFiles = files.second
-        PackageFiles(projectRoot, Some(packageFile), files.first)
-    }
-    let singleFileProjects = singleFiles.map {file => 
-        let projectRoot = file.parent().grab()
-        PackageFiles(projectRoot, None, [file])
-    }
-    [...multiFileProjects, ...singleFileProjects]
-}
-
-findFireflyFiles(
-    path: Path
-    mustContain: Option[String]
-    skipFiles: Set[String]
-): List[Path] {
-    let split = path.entries().toList().partition {_.isDirectory()}
-    let directories = split.first.map {_.path()}.filter {_.base().all {c => 
-        c == '.' || c.isAsciiLower() || c.isAsciiDigit()
-    }}
-    let fireflyFiles = split.second.map {_.path()}.filter {file => 
-        file.extension() == ".ff" && !skipFiles.contains(file.absolute()) && mustContain.all {s => 
-            file.readText().contains(s)
-        }
-    }
-    [...fireflyFiles, ...directories.flatMap {findFireflyFiles(_, mustContain, skipFiles)}]
-}
-
-internalCreateExecutable(
-    self: BuildSystem
-    mainJsFile: Path = ".firefly/output/executable/Main.bundle.js"
-    outputPath: Path = ".firefly/output"
-    targets: List[String] = ["host"]
-    assets: AssetSystem = AssetSystem.create()
-): Unit
-    target node {
-        let assetOutputPath = outputPath.slash("assets")
-        assets.files.pairs().each {| Pair(path, makeStream) =>
-            let p = assetOutputPath.slash(path)
-            p.parent().grab().createDirectory(createParentDirectories = True)
-            p.writeStream(makeStream())
-        }
-        let json = """{
-            "name": "main",
-            "bin": {
-                "firefly-main": "Main.bundle.js"
-            },
-            "devDependencies": {
-                "pkg": "^5.8.0"
-            },
-            "pkg": {
-                "scripts": "Main.bundle.js",
-                "outputPath": "bin",
-                "assets": ["../assets/**/*"],
-                "targets": [
-                    "node18-linux-x64",
-                    "node18-macos-x64",
-                    "node18-win-x64"
-                ]
-            }
-        }"""
-        let packageFile = outputPath.slash("executable/package.json")
-        packageFile.writeText(json)
-        internalCallPkg(self, packageFile, outputPath, targets)
-    }
-
-internalCallPkg(
-    self: BuildSystem
-    packageFile: Path
-    outputPath: Path
-    targets: List[String]
-): Unit
-    target node async """
-        import * as pkg from 'pkg'
-        return await pkg.exec([
-            packageFile_,
-            '--out-path', outputPath_,
-            '--target', targets_.join(',')
-        ])
-    """
+import Tokenizer
+import Parser
+import Syntax
+import Resolver
+import Compiler
+import Unification
+import Dependencies
+import JsEmitter
+import ModuleCache
+import LspHook
+import DependencyLock
+
+build(
+    system: NodeSystem
+    emitTarget: EmitTarget
+    mainPackage: PackagePair
+    mainModule: String
+    resolvedDependencies: ResolvedDependencies
+    compilerModulePath: Option[Path]
+    tempPath: Path
+    jsOutputPath: Path
+    printMeasurements: Bool
+    moduleCache: ModuleCache
+): Unit {
+
+    if(tempPath.exists()) {tempPath.delete()}
+    tempPath.createDirectory()
+
+    let jsPathFile = tempPath.slash("js")
+    jsPathFile.createDirectory(createParentDirectories = True)
+
+    let success = do {
+        let compiler = Compiler.new(
+            emitTarget
+            system.mainTask()
+            compilerModulePath
+            jsPathFile
+            resolvedDependencies
+            Map.new()
+            moduleCache
+            lspHook = LspHook.disabled()
+        )
+        compiler.emit(mainPackage, mainModule, isMainModule = True)
+        if(printMeasurements) {compiler.printMeasurements()}
+        resolvedDependencies.packagePaths.each {packagePair, packagePath =>
+            resolvedDependencies.packages.get(packagePair).each {packageInfo =>
+                processIncludes(jsPathFile, packagePath, packageInfo)
+            }
+        }
+        True
+    }
+
+    if(success) {
+        if(jsOutputPath.exists()) {jsOutputPath.delete()}
+        jsPathFile.renameTo(jsOutputPath)
+    }
+
+}
+
+processIncludes(jsPathFile: Path, packagePath: Path, info: PackageInfo): Unit {
+    info.includes.each {include =>
+        let fromPath = packagePath.slash(".firefly").slash("include").slash(include.path)
+        let toPath = jsPathFile.slash(info.package.packagePair.groupName("/")).slash(include.path)
+        fromPath.copyTo(toPath)
+    }
+}
+
+buildViaBuildSystem(system: NodeSystem, fireflyPath: Path, mainFile: String, target: String) {
+    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 {
+        resolvedDependencies.packagePaths.add(PackagePair("ff", "core"), fireflyPath.slash("core"))
+    }
+    if(target != "browser") {
+        panic("buildViaBuildSystem is currently limited to browser target only - the restriction can be lifted")
+    }
+    build(
+        system = system
+        emitTarget = EmitBrowser
+        mainPackage = resolvedDependencies.mainPackagePair
+        mainModule = mainFile.dropLast(".ff".size())
+        resolvedDependencies = resolvedDependencies.ResolvedDependencies(packagePaths = fixedPackagePaths)
+        compilerModulePath = None
+        tempPath = system.path(".firefly/temporary")
+        jsOutputPath = system.path(".firefly/output").slash(target)
+        printMeasurements = False
+        moduleCache = ModuleCache.new(0)
+    )
+}
+
+check(
+    system: NodeSystem
+    fireflyPath: Path
+    path: Path
+    mustContain: Option[String]
+    skipFiles: Set[String]
+    virtualFiles: Map[String, String]
+    cache: ModuleCache
+    dependencyLock: DependencyLock
+    newVersion: Int
+    lspHook: LspHook
+    infer: Bool
+    checkDependencies: Bool
+): List[CompileError] {
+    let packages = path.isDirectory().{
+        | True => findPackageFiles(path, mustContain, skipFiles)
+        | False {path.endsWith([".firefly", "package.ff"])} => [PackageFiles(path.parent().grab(), Some(path), [])]
+        | False => [PackageFiles(path.parent().grab(), None, [path])]
+    }
+    let errors = Array.new()
+
+    packages.filter {!_.files.isEmpty()}.each {package => 
+        let firstFile = package.files.grabFirst()
+        let resolvedDependencies = Dependencies.process(system.httpClient(), dependencyLock, firstFile)
+        let fixedPackagePaths = if(resolvedDependencies.packagePaths.contains(PackagePair("ff", "core"))) {
+            resolvedDependencies.packagePaths
+        } else {
+            resolvedDependencies.packagePaths.add(PackagePair("ff", "core"), fireflyPath.slash("core"))
+        }
+        let fixedResolvedDependencies = resolvedDependencies.ResolvedDependencies(packagePaths = fixedPackagePaths)
+        let newCache = cache.without(newVersion, path)
+        let compiler = Compiler.new(
+            EmitBuild
+            system.mainTask() 
+            None
+            package.root.slash(".firefly").slash("temporary")
+            fixedResolvedDependencies
+            virtualFiles
+            newCache
+            lspHook
+        )
+        let files = if(checkDependencies) {package.files} else {
+            package.files.filter {!_.contains([".firefly", "dependencies"])}
+        }
+        files.each {file =>
+            let localFile = file.base()
+            try {
+                if(infer) {
+                    compiler.infer(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
+                } else {
+                    compiler.resolve(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
+                }
+            } tryCatch {| CompileError(_, _) @ c, error =>
+                errors.push(c)
+            } catch {| CompileErrors(compileErrors), error =>
+                errors.pushList(compileErrors)
+            }
+        }
+        cache.mergeVersions(compiler.cache)
+    }
+    errors.drain()
+
+}
+
+capability PackageFiles(
+    root: Path
+    packageFile: Option[Path]
+    files: List[Path]
+)
+
+
+findPackageFiles(
+    path: Path
+    mustContain: Option[String]
+    skipFiles: Set[String]
+): List[PackageFiles] {
+    let files = findFireflyFiles(path, mustContain, skipFiles)
+    let split = files.partition {_.endsWith([".firefly", "package.ff"])}
+    let packageFiles = split.first
+    mutable singleFiles = split.second
+    let multiFileProjects = packageFiles.map {packageFile => 
+        let projectRoot = packageFile.parent().grab().parent().grab()
+        let files = singleFiles.partition {_.isInsideOf(projectRoot)}
+        singleFiles = files.second
+        PackageFiles(projectRoot, Some(packageFile), files.first)
+    }
+    let singleFileProjects = singleFiles.map {file => 
+        let projectRoot = file.parent().grab()
+        PackageFiles(projectRoot, None, [file])
+    }
+    [...multiFileProjects, ...singleFileProjects]
+}
+
+findFireflyFiles(
+    path: Path
+    mustContain: Option[String]
+    skipFiles: Set[String]
+): List[Path] {
+    let split = path.entries().toList().partition {_.isDirectory()}
+    let directories = split.first.map {_.path()}.filter {_.base().all {c => 
+        c == '.' || c.isAsciiLower() || c.isAsciiDigit()
+    }}
+    let fireflyFiles = split.second.map {_.path()}.filter {file => 
+        file.extension() == ".ff" && !skipFiles.contains(file.absolute()) && mustContain.all {s => 
+            file.readText().contains(s)
+        }
+    }
+    [...fireflyFiles, ...directories.flatMap {findFireflyFiles(_, mustContain, skipFiles)}]
+}
+
+internalCreateExecutable(
+    self: BuildSystem
+    mainJsFile: Path = ".firefly/output/executable/Main.bundle.js"
+    outputPath: Path = ".firefly/output"
+    targets: List[String] = ["host"]
+    assets: AssetSystem = AssetSystem.create()
+): Unit
+    target node {
+        let assetOutputPath = outputPath.slash("assets")
+        assets.files.pairs().each {| Pair(path, makeStream) =>
+            let p = assetOutputPath.slash(path)
+            p.parent().grab().createDirectory(createParentDirectories = True)
+            p.writeStream(makeStream())
+        }
+        let json = """{
+            "name": "main",
+            "bin": {
+                "firefly-main": "Main.bundle.js"
+            },
+            "devDependencies": {
+                "pkg": "^5.8.0"
+            },
+            "pkg": {
+                "scripts": "Main.bundle.js",
+                "outputPath": "bin",
+                "assets": ["../assets/**/*"],
+                "targets": [
+                    "node18-linux-x64",
+                    "node18-macos-x64",
+                    "node18-win-x64"
+                ]
+            }
+        }"""
+        let packageFile = outputPath.slash("executable/package.json")
+        packageFile.writeText(json)
+        internalCallPkg(self, packageFile, outputPath, targets)
+    }
+
+internalCallPkg(
+    self: BuildSystem
+    packageFile: Path
+    outputPath: Path
+    targets: List[String]
+): Unit
+    target node async """
+        import * as pkg from 'pkg'
+        return await pkg.exec([
+            packageFile_,
+            '--out-path', outputPath_,
+            '--target', targets_.join(',')
+        ])
+    """