firefly-compiler 0.4.40 → 0.4.48

package/compiler/Dependencies.ff

@@ -1,186 +1,186 @@
-import Parser
-import Syntax
-import Tokenizer
-import Workspace
-import LspHook
-import DependencyLock
-
-capability Dependencies(
-    workspace: Workspace
-    mutable packages: Map[PackagePair, PackageInfo]
-    mutable packagePaths: Map[PackagePair, Path]
-    mutable singleFilePackages: Set[PackagePair]
-)
-
-capability ResolvedDependencies(
-    mainPackagePair: PackagePair
-    packages: Map[PackagePair, PackageInfo]
-    packagePaths: Map[PackagePair, Path]
-    singleFilePackages: Set[PackagePair]
-)
-
-extend self: Dependencies {
-
-    loadPackageInfo(
-        packagePair: PackagePair
-        path: Path
-    ): 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()) {
-            sharedPackageFile
-        } else {
-            self.singleFilePackages = self.singleFilePackages.add(packagePair)
-            path
-        }
-        let code = packageFile.readText()
-        self.parsePackageFile(packagePair, packageFile.relativeTo(path), code)
-    }
-    
-    parsePackageFile(
-        packagePair: PackagePair
-        fileName: String
-        code: String
-    ): PackageInfo {
-        let tokens = Tokenizer.tokenize(fileName, code, None, True)
-        let parser = Parser.new(packagePair, fileName, tokens, False, LspHook.disabled())
-        let info = parser.parsePackageInfo()
-        self.addCoreDependencyIfMissing(info)
-    }
-
-    addCoreDependencyIfMissing(info: PackageInfo): PackageInfo {
-        if(info.dependencies.any {d =>
-            d.packagePair.group == "ff" && d.packagePair.name == "core"
-        }) {
-            info
-        } else {
-            let coreDependency = DDependency(
-                at = info.package.at
-                packagePair = PackagePair("ff", "core")
-                version = Version(info.package.at, 0, 0, 0)
-                safety = Trusted
-                targets = info.package.targets
-            )
-            info.PackageInfo(dependencies = [coreDependency, ...info.dependencies])
-        }
-    }
-
-    processPackageInfo(
-        packageInfo: PackageInfo
-    ): List[DDependency] {
-        self.packages = self.packages.add(packageInfo.package.packagePair, packageInfo)
-        packageInfo.dependencies.filter {!self.packages.contains(_.packagePair)}
-    }
-
-    fetchDependency(
-        path: Path
-        httpClient: HttpClient
-        dependencyLock: DependencyLock
-        dependency: DDependency
-    ): Path {
-        let location = self.workspace.findPackageLocation(dependency.packagePair, dependency.version)
-        if(location.contains(":") && !location.dropFirst(1).startsWith(":")) {
-            if(location.startsWith("http://") || location.startsWith("https://")) {
-                let packagePair = dependency.packagePair
-                let directory = if(path.isDirectory()) {path} else {path.parent().grab()}
-                let dependenciesPath = directory.slash(".firefly").slash("dependencies")
-                let dependencyPath = dependenciesPath.slash(packagePair.group).slash(packagePair.name)
-                let tarGzPath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version))
-                let donePath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version) + ".done")
-                if(!donePath.exists()) {
-                    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)
-                        }
-                    }
-                }
-                dependencyPath
-            } else {
-                panic("Loading packages by this protocol is not supported: " + location)
-            }
-        } else {
-            path.path(location)
-        }
-    }
-
-    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, dependencyLock, dependency)
-            self.packagePaths = self.packagePaths.add(dependency.packagePair, dependencyPath)
-            let packageInfo = self.loadPackageInfo(dependency.packagePair, dependencyPath)
-            checkPackagePairs(dependency.packagePair, packageInfo.package.packagePair)
-            packageInfo
-        }
-        let newDependencies = packageInfos.flatMap {self.processPackageInfo(_)}
-        if(newDependencies != []) {
-            self.processDependencies(path, httpClient, dependencyLock, newDependencies)
-        }
-    }
-
-}
-
-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, dependencyLock, newDependencies)
-    let packagePaths = self.packagePaths.add(packageInfo.package.packagePair, findScriptPackageLocation(path))
-    ResolvedDependencies(
-        mainPackagePair = packageInfo.package.packagePair
-        packages = self.packages
-        packagePaths = packagePaths
-        singleFilePackages = self.singleFilePackages
-    )
-}
-
-findScriptPackageLocation(path: Path): Path {
-    let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
-    function go(directory: Path): Path {
-        let packageFile = directory.slash(".firefly").slash("package.ff")
-        if(packageFile.exists()) {
-            directory
-        } elseIf {!directory.parent().isEmpty()} {
-            go(directory.parent().grab())
-        } else {
-            packageDirectory
-        }
-    }
-    go(packageDirectory)
-}
-
-checkPackagePairs(dependencyPair: PackagePair, packagePair: PackagePair): Unit {
-    if(
-        packagePair.group != dependencyPair.group ||
-        packagePair.name != dependencyPair.name
-    ) {
-        panic(
-            "Dependency declaration and package declaration disagree on package name: " +
-            dependencyPair.groupName() + " vs. " + packagePair.groupName()
-        )
-    }
-}
-
-internalExtractTarGz(tarGzPath: Path, path: Path): Unit
-    target node async """
-        import * as tar from 'tar'
-        await tar.extract({file: tarGzPath_, cwd: path_, strict: true})
-    """
+import Parser
+import Syntax
+import Tokenizer
+import Workspace
+import LspHook
+import DependencyLock
+
+capability Dependencies(
+    workspace: Workspace
+    mutable packages: Map[PackagePair, PackageInfo]
+    mutable packagePaths: Map[PackagePair, Path]
+    mutable singleFilePackages: Set[PackagePair]
+)
+
+capability ResolvedDependencies(
+    mainPackagePair: PackagePair
+    packages: Map[PackagePair, PackageInfo]
+    packagePaths: Map[PackagePair, Path]
+    singleFilePackages: Set[PackagePair]
+)
+
+extend self: Dependencies {
+
+    loadPackageInfo(
+        packagePair: PackagePair
+        path: Path
+    ): 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()) {
+            sharedPackageFile
+        } else {
+            self.singleFilePackages = self.singleFilePackages.add(packagePair)
+            path
+        }
+        let code = packageFile.readText()
+        self.parsePackageFile(packagePair, packageFile.relativeTo(path), code)
+    }
+    
+    parsePackageFile(
+        packagePair: PackagePair
+        fileName: String
+        code: String
+    ): PackageInfo {
+        let tokens = Tokenizer.tokenize(fileName, code, None, True)
+        let parser = Parser.new(packagePair, fileName, tokens, False, LspHook.disabled())
+        let info = parser.parsePackageInfo()
+        self.addCoreDependencyIfMissing(info)
+    }
+
+    addCoreDependencyIfMissing(info: PackageInfo): PackageInfo {
+        if(info.dependencies.any {d =>
+            d.packagePair.group == "ff" && d.packagePair.name == "core"
+        }) {
+            info
+        } else {
+            let coreDependency = DDependency(
+                at = info.package.at
+                packagePair = PackagePair("ff", "core")
+                version = Version(info.package.at, 0, 0, 0)
+                safety = Trusted
+                targets = info.package.targets
+            )
+            info.PackageInfo(dependencies = [coreDependency, ...info.dependencies])
+        }
+    }
+
+    processPackageInfo(
+        packageInfo: PackageInfo
+    ): List[DDependency] {
+        self.packages = self.packages.add(packageInfo.package.packagePair, packageInfo)
+        packageInfo.dependencies.filter {!self.packages.contains(_.packagePair)}
+    }
+
+    fetchDependency(
+        path: Path
+        httpClient: HttpClient
+        dependencyLock: DependencyLock
+        dependency: DDependency
+    ): Path {
+        let location = self.workspace.findPackageLocation(dependency.packagePair, dependency.version)
+        if(location.contains(":") && !location.dropFirst(1).startsWith(":")) {
+            if(location.startsWith("http://") || location.startsWith("https://")) {
+                let packagePair = dependency.packagePair
+                let directory = if(path.isDirectory()) {path} else {path.parent().grab()}
+                let dependenciesPath = directory.slash(".firefly").slash("dependencies")
+                let dependencyPath = dependenciesPath.slash(packagePair.group).slash(packagePair.name)
+                let tarGzPath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version))
+                let donePath = dependenciesPath.slash(Workspace.tarGzName(packagePair, dependency.version) + ".done")
+                if(!donePath.exists()) {
+                    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)
+                        }
+                    }
+                }
+                dependencyPath
+            } else {
+                panic("Loading packages by this protocol is not supported: " + location)
+            }
+        } else {
+            path.path(location)
+        }
+    }
+
+    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, dependencyLock, dependency)
+            self.packagePaths = self.packagePaths.add(dependency.packagePair, dependencyPath)
+            let packageInfo = self.loadPackageInfo(dependency.packagePair, dependencyPath)
+            checkPackagePairs(dependency.packagePair, packageInfo.package.packagePair)
+            packageInfo
+        }
+        let newDependencies = packageInfos.flatMap {self.processPackageInfo(_)}
+        if(newDependencies != []) {
+            self.processDependencies(path, httpClient, dependencyLock, newDependencies)
+        }
+    }
+
+}
+
+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, dependencyLock, newDependencies)
+    let packagePaths = self.packagePaths.add(packageInfo.package.packagePair, findScriptPackageLocation(path))
+    ResolvedDependencies(
+        mainPackagePair = packageInfo.package.packagePair
+        packages = self.packages
+        packagePaths = packagePaths
+        singleFilePackages = self.singleFilePackages
+    )
+}
+
+findScriptPackageLocation(path: Path): Path {
+    let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
+    function go(directory: Path): Path {
+        let packageFile = directory.slash(".firefly").slash("package.ff")
+        if(packageFile.exists()) {
+            directory
+        } elseIf {!directory.parent().isEmpty()} {
+            go(directory.parent().grab())
+        } else {
+            packageDirectory
+        }
+    }
+    go(packageDirectory)
+}
+
+checkPackagePairs(dependencyPair: PackagePair, packagePair: PackagePair): Unit {
+    if(
+        packagePair.group != dependencyPair.group ||
+        packagePair.name != dependencyPair.name
+    ) {
+        panic(
+            "Dependency declaration and package declaration disagree on package name: " +
+            dependencyPair.groupName() + " vs. " + packagePair.groupName()
+        )
+    }
+}
+
+internalExtractTarGz(tarGzPath: Path, path: Path): Unit
+    target node async """
+        import * as tar from 'tar'
+        await tar.extract({file: tarGzPath_, cwd: path_, strict: true})
+    """

package/compiler/DependencyLock.ff

@@ -1,17 +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()
-        }
-    }
-}
+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()
+        }
+    }
+}