firefly-compiler 0.4.79 → 0.4.80

package/compiler/ModuleCache.ff

@@ -1,178 +1,178 @@
-import Syntax
-
-class ModuleCache(
-    version: Int
-    mutable parsedModules: Map[String, Pair[Module, Int]]
-    mutable resolvedModules: Map[String, Pair[Module, Int]]
-    mutable derivedModules: Map[String, Pair[Module, Int]]
-    mutable inferredModules: Map[String, Pair[Module, Int]]
-    mutable emittedModules: Map[String, Int]
-)
-
-new(version: Int): ModuleCache {
-    ModuleCache(
-        version = version
-        parsedModules = Map.new()
-        resolvedModules = Map.new()
-        derivedModules = Map.new()
-        inferredModules = Map.new()
-        emittedModules = Map.new()
-    )
-}
-
-extend self: ModuleCache {
-    
-    remove(keys: List[String]) {
-        if(!keys.isEmpty()):
-        self.parsedModules = self.parsedModules.removeList(keys)
-        self.resolvedModules = self.resolvedModules.removeList(keys)
-        self.derivedModules = self.derivedModules.removeList(keys)
-        self.inferredModules = self.inferredModules.removeList(keys)
-        self.emittedModules = self.emittedModules.removeList(keys)
-    }
-    
-    invalidate(key: String) {
-        //Log.trace("Invalidate: " + uri)
-        self.parsedModules.get(key).each: | Pair(module, _) =>
-        let moduleName = module.file.dropLast(3)
-        self.remove([key])
-        self.parsedModules.each {| k, Pair(m, _) =>
-            if(m.imports.any {i => i.package == module.packagePair && i.file == moduleName}) {
-                //Log.trace("Invalidating due to import of invalidated module: " + m.packagePair.groupName() + "/" + m.file)
-                self.remove([k])
-            }
-        }
-    }
-    
-    filesNotImporting(packagePair: PackagePair, moduleName: String): List[String] {
-        self.parsedModules.toList().collect {| Pair(k, Pair(m, _)) =>
-            if(!m.imports.any {i => i.package == packagePair && i.file == moduleName}): k
-        }
-    }
-    
-    without(newVersion: Int, path: Path): ModuleCache {
-        let key = path.absolute()
-        if(path.isFile()) {
-            self.ModuleCache(
-                version = newVersion
-                parsedModules = self.parsedModules.remove(key)
-                resolvedModules = self.resolvedModules.remove(key)
-                derivedModules = self.derivedModules.remove(key)
-                inferredModules = self.inferredModules.remove(key)
-                emittedModules = self.emittedModules.remove(key)
-            )
-        } else {
-            function invalidated(p: String): Bool {
-                p.startsWith(key) && !p.contains(".firefly/dependencies") && !p.contains(".firefly\\dependencies")
-            }
-            self.ModuleCache(
-                version = newVersion
-                parsedModules = self.parsedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
-                resolvedModules = self.resolvedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
-                derivedModules = self.derivedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
-                inferredModules = self.inferredModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
-                emittedModules = self.emittedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
-            )
-        }
-    }
-    
-    mergeVersions(cache: ModuleCache): Unit {
-        self.parsedModules = mergeVersionedMap(self.parsedModules, cache.parsedModules) {_.second}
-        self.resolvedModules = mergeVersionedMap(self.resolvedModules, cache.resolvedModules) {_.second}
-        self.derivedModules = mergeVersionedMap(self.derivedModules, cache.derivedModules) {_.second}
-        self.inferredModules = mergeVersionedMap(self.inferredModules, cache.inferredModules) {_.second}
-        self.emittedModules = mergeVersionedMap(self.emittedModules, cache.emittedModules) {_}
-    }
-    
-    cacheParsedModule(
-        packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
-        body: Path => Module
-    ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
-        self.parsedModules.get(path.absolute()).map {_.first}.else:
-        let result = body(path)
-        self.parsedModules = self.parsedModules.add(path.absolute(), Pair(result, self.version))
-        result
-    }
-    
-    cacheResolvedModule(
-        packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
-        body: Path => Module
-    ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
-        self.resolvedModules.get(path.absolute()).map {_.first}.else:
-        let result = body(path)
-        self.resolvedModules = self.resolvedModules.add(path.absolute(), Pair(result, self.version))
-        result
-    }
-
-    cacheDerivedModule(
-        packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
-        body: Path => Module
-    ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
-        self.derivedModules.get(path.absolute()).map {_.first}.else:
-        let result = body(path)
-        self.derivedModules = self.derivedModules.add(path.absolute(), Pair(result, self.version))
-        result
-    }
-        
-    cacheInferredModule(
-        packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
-        body: Path => Module
-    ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
-        self.inferredModules.get(path.absolute()).map {_.first}.else:
-        let result = body(path)
-        self.inferredModules = self.inferredModules.add(path.absolute(), Pair(result, self.version))
-        result
-    }
- 
-    cacheEmittedModule(
-        packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
-        body: Path => Unit
-    ): Unit {
-        let path = modulePath(packagePaths, packagePair, moduleName)
-        if(!self.emittedModules.contains(path.absolute())):
-        self.emittedModules = self.emittedModules.add(path.absolute(), self.version)
-        try {
-            body(path)
-        } catchAny {error =>
-            self.emittedModules = self.emittedModules.remove(path.absolute())
-            error.rethrow()
-        } grab()
-    }
-    
-}
-
-mergeVersionedMap[T](oldMap: Map[String, T], newMap: Map[String, T], getVersion: T => Int): Map[String, T] {
-    mutable result = newMap
-    oldMap.each {k, v =>
-        if(!newMap.get(k).any {getVersion(_) >= getVersion(v)}) {
-            result = result.add(k, v)
-        }
-    }
-    result
-}
-
-modulePath(
-    packagePaths: Map[PackagePair, Path]
-    packagePair: PackagePair
-    moduleName: String
-): Path {
-    let packagePath = packagePaths.get(packagePair).else {
-        panic("Internal error - package path missing: " + packagePair.groupName())
-    }
-    let file = moduleName + ".ff"
-    packagePath.slash(file)
-}
+import Syntax
+
+class ModuleCache(
+    version: Int
+    mutable parsedModules: Map[String, Pair[Module, Int]]
+    mutable resolvedModules: Map[String, Pair[Module, Int]]
+    mutable derivedModules: Map[String, Pair[Module, Int]]
+    mutable inferredModules: Map[String, Pair[Module, Int]]
+    mutable emittedModules: Map[String, Int]
+)
+
+new(version: Int): ModuleCache {
+    ModuleCache(
+        version = version
+        parsedModules = Map.new()
+        resolvedModules = Map.new()
+        derivedModules = Map.new()
+        inferredModules = Map.new()
+        emittedModules = Map.new()
+    )
+}
+
+extend self: ModuleCache {
+    
+    remove(keys: List[String]) {
+        if(!keys.isEmpty()):
+        self.parsedModules = self.parsedModules.removeList(keys)
+        self.resolvedModules = self.resolvedModules.removeList(keys)
+        self.derivedModules = self.derivedModules.removeList(keys)
+        self.inferredModules = self.inferredModules.removeList(keys)
+        self.emittedModules = self.emittedModules.removeList(keys)
+    }
+    
+    invalidate(key: String) {
+        //Log.trace("Invalidate: " + uri)
+        self.parsedModules.get(key).each: | Pair(module, _) =>
+        let moduleName = module.file.dropLast(3)
+        self.remove([key])
+        self.parsedModules.each {| k, Pair(m, _) =>
+            if(m.imports.any {i => i.package == module.packagePair && i.file == moduleName}) {
+                //Log.trace("Invalidating due to import of invalidated module: " + m.packagePair.groupName() + "/" + m.file)
+                self.remove([k])
+            }
+        }
+    }
+    
+    filesNotImporting(packagePair: PackagePair, moduleName: String): List[String] {
+        self.parsedModules.toList().collect {| Pair(k, Pair(m, _)) =>
+            if(!m.imports.any {i => i.package == packagePair && i.file == moduleName}): k
+        }
+    }
+    
+    without(newVersion: Int, path: Path): ModuleCache {
+        let key = path.absolute()
+        if(path.isFile()) {
+            self.ModuleCache(
+                version = newVersion
+                parsedModules = self.parsedModules.remove(key)
+                resolvedModules = self.resolvedModules.remove(key)
+                derivedModules = self.derivedModules.remove(key)
+                inferredModules = self.inferredModules.remove(key)
+                emittedModules = self.emittedModules.remove(key)
+            )
+        } else {
+            function invalidated(p: String): Bool {
+                p.startsWith(key) && !p.contains(".firefly/dependencies") && !p.contains(".firefly\\dependencies")
+            }
+            self.ModuleCache(
+                version = newVersion
+                parsedModules = self.parsedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
+                resolvedModules = self.resolvedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
+                derivedModules = self.derivedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
+                inferredModules = self.inferredModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
+                emittedModules = self.emittedModules.toList().filter {| Pair(p, _) => !invalidated(p)}.toMap()
+            )
+        }
+    }
+    
+    mergeVersions(cache: ModuleCache): Unit {
+        self.parsedModules = mergeVersionedMap(self.parsedModules, cache.parsedModules) {_.second}
+        self.resolvedModules = mergeVersionedMap(self.resolvedModules, cache.resolvedModules) {_.second}
+        self.derivedModules = mergeVersionedMap(self.derivedModules, cache.derivedModules) {_.second}
+        self.inferredModules = mergeVersionedMap(self.inferredModules, cache.inferredModules) {_.second}
+        self.emittedModules = mergeVersionedMap(self.emittedModules, cache.emittedModules) {_}
+    }
+    
+    cacheParsedModule(
+        packagePaths: Map[PackagePair, Path]
+        packagePair: PackagePair
+        moduleName: String
+        body: Path => Module
+    ): Module {
+        let path = modulePath(packagePaths, packagePair, moduleName)
+        self.parsedModules.get(path.absolute()).map {_.first}.else:
+        let result = body(path)
+        self.parsedModules = self.parsedModules.add(path.absolute(), Pair(result, self.version))
+        result
+    }
+    
+    cacheResolvedModule(
+        packagePaths: Map[PackagePair, Path]
+        packagePair: PackagePair
+        moduleName: String
+        body: Path => Module
+    ): Module {
+        let path = modulePath(packagePaths, packagePair, moduleName)
+        self.resolvedModules.get(path.absolute()).map {_.first}.else:
+        let result = body(path)
+        self.resolvedModules = self.resolvedModules.add(path.absolute(), Pair(result, self.version))
+        result
+    }
+
+    cacheDerivedModule(
+        packagePaths: Map[PackagePair, Path]
+        packagePair: PackagePair
+        moduleName: String
+        body: Path => Module
+    ): Module {
+        let path = modulePath(packagePaths, packagePair, moduleName)
+        self.derivedModules.get(path.absolute()).map {_.first}.else:
+        let result = body(path)
+        self.derivedModules = self.derivedModules.add(path.absolute(), Pair(result, self.version))
+        result
+    }
+        
+    cacheInferredModule(
+        packagePaths: Map[PackagePair, Path]
+        packagePair: PackagePair
+        moduleName: String
+        body: Path => Module
+    ): Module {
+        let path = modulePath(packagePaths, packagePair, moduleName)
+        self.inferredModules.get(path.absolute()).map {_.first}.else:
+        let result = body(path)
+        self.inferredModules = self.inferredModules.add(path.absolute(), Pair(result, self.version))
+        result
+    }
+ 
+    cacheEmittedModule(
+        packagePaths: Map[PackagePair, Path]
+        packagePair: PackagePair
+        moduleName: String
+        body: Path => Unit
+    ): Unit {
+        let path = modulePath(packagePaths, packagePair, moduleName)
+        if(!self.emittedModules.contains(path.absolute())):
+        self.emittedModules = self.emittedModules.add(path.absolute(), self.version)
+        try {
+            body(path)
+        } catchAny {error =>
+            self.emittedModules = self.emittedModules.remove(path.absolute())
+            error.rethrow()
+        }
+    }
+    
+}
+
+mergeVersionedMap[T](oldMap: Map[String, T], newMap: Map[String, T], getVersion: T => Int): Map[String, T] {
+    mutable result = newMap
+    oldMap.each {k, v =>
+        if(!newMap.get(k).any {getVersion(_) >= getVersion(v)}) {
+            result = result.add(k, v)
+        }
+    }
+    result
+}
+
+modulePath(
+    packagePaths: Map[PackagePair, Path]
+    packagePair: PackagePair
+    moduleName: String
+): Path {
+    let packagePath = packagePaths.get(packagePair).else {
+        panic("Internal error - package path missing: " + packagePair.groupName())
+    }
+    let file = moduleName + ".ff"
+    packagePath.slash(file)
+}

package/compiler/Tokenizer.ff

@@ -268,7 +268,7 @@ tokenize(file: String, code: String, completionAt: Option[Location], attemptFixe
         }
     } catch {| GrabException e, error =>
         throw(CompileError(Location(file, line, i - lineOffset), "Unexpected end of file"))
-    } grab()
+    }
 
     List.range(5).each {_ => emitToken(LEnd, i, i) }
 

package/compiler/Unification.ff

@@ -67,7 +67,7 @@ extend self: Unification {
             body()
         } finally {
             self.instances = oldInstances
-        } grab()
+        }
     }
 
     freshUnificationVariable(at: Location): Type {

package/compiler/Workspace.ff

@@ -1,88 +1,88 @@
-import Syntax
-
-data Workspace(
-    rules: List[WorkspaceRule]
-    defaultLocation: String
-    packageDirectory: String
-)
-
-data WorkspaceRule(
-    packageGroup: String
-    packageName: Option[String]
-    location: String
-)
-
-centralLocation = "https://www.firefly-lang.org/packages/"
-
-loadWorkspace(path: Path): Workspace {
-    let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
-    let workspaceFile = packageDirectory.slash(".firefly-workspace")
-    if(workspaceFile.exists()) {
-        parseWorkspaceFile(workspaceFile, packageDirectory)
-    } elseIf {!packageDirectory.parent().isEmpty()} {
-        loadWorkspace(packageDirectory.parent().grab())
-    } else {
-        Workspace([], centralLocation, ".")
-    }
-}
-
-parseWorkspaceFile(path: Path, packageDirectory: Path): Workspace {
-    let text = path.readText()
-    mutable defaultLocation = None
-    let lines = text.split('\n').map {_.replace("\r", "").takeWhile {_ != '#'}}.filter {_.size() != 0}
-    let rules = lines.collect {line =>
-        let columns = line.replace("\t", " ").split(' ').filter {_.size() != 0}
-        defaultLocation.each {_ =>
-            panic("Unexpected rule after the * rule: " + line)
-        }
-        if(columns.size() != 2) {
-            panic("Could not parse workspace rule: " + line)
-        }
-        let package = columns.grab(0)
-        let location = columns.grab(1)
-        let fixedLocation = if(location.endsWith("/")) {location} else {location + "/"}
-        if(package == "*") {
-            defaultLocation = Some(fixedLocation)
-            None
-        } else {
-            let packageParts = package.split(':')
-            if(packageParts.size() != 2) {
-                panic("Could not parse workspace package: " + package)
-            }
-            if(packageParts.grab(0) == "*") {
-                panic("Unexpected wildcard: " + package)
-            }
-            Some(WorkspaceRule(
-                packageGroup = packageParts.grab(0)
-                packageName = if(packageParts.grab(1) != "*") {packageParts.grab(1)}
-                location = fixedLocation
-            ))
-        }
-    }
-    Workspace(rules, defaultLocation.else {centralLocation}, packageDirectory.absolute())
-}
-
-extend self: Workspace {
-
-    findPackageLocation(packagePair: PackagePair, version: Version): String {
-        self.rules.find {rule =>
-            rule.packageGroup == packagePair.group && rule.packageName.all {_ == packagePair.name}
-        }.map {rule =>
-            let prefix = if(rule.packageName == None) {packagePair.name + "/"} else {""}
-            if(rule.location.contains(":")) {
-                rule.location + prefix + tarGzName(packagePair, version)
-            } else {
-                self.packageDirectory + "/" + rule.location + prefix
-            }
-        }.else {
-            self.defaultLocation + packagePair.group + "/" + packagePair.name + "/" +
-            tarGzName(packagePair, version)
-        }
-    }
-
-}
-
-tarGzName(packagePair: PackagePair, version: Version): String {
-    packagePair.group + "_" + packagePair.name + "_" +
-    version.major + "_" + version.minor + "_" + version.patch + ".tar.gz"
-}
+import Syntax
+
+data Workspace(
+    rules: List[WorkspaceRule]
+    defaultLocation: String
+    packageDirectory: String
+)
+
+data WorkspaceRule(
+    packageGroup: String
+    packageName: Option[String]
+    location: String
+)
+
+centralLocation = "https://www.firefly-lang.org/packages/"
+
+loadWorkspace(path: Path): Workspace {
+    let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
+    let workspaceFile = packageDirectory.slash(".firefly-workspace")
+    if(workspaceFile.exists()) {
+        parseWorkspaceFile(workspaceFile, packageDirectory)
+    } elseIf {!packageDirectory.parent().isEmpty()} {
+        loadWorkspace(packageDirectory.parent().grab())
+    } else {
+        Workspace([], centralLocation, ".")
+    }
+}
+
+parseWorkspaceFile(path: Path, packageDirectory: Path): Workspace {
+    let text = path.readText()
+    mutable defaultLocation = None
+    let lines = text.split('\n').map {_.replace("\r", "").takeWhile {_ != '#'}}.filter {_.size() != 0}
+    let rules = lines.collect {line =>
+        let columns = line.replace("\t", " ").split(' ').filter {_.size() != 0}
+        defaultLocation.each {_ =>
+            panic("Unexpected rule after the * rule: " + line)
+        }
+        if(columns.size() != 2) {
+            panic("Could not parse workspace rule: " + line)
+        }
+        let package = columns.grab(0)
+        let location = columns.grab(1)
+        let fixedLocation = if(location.endsWith("/")) {location} else {location + "/"}
+        if(package == "*") {
+            defaultLocation = Some(fixedLocation)
+            None
+        } else {
+            let packageParts = package.split(':')
+            if(packageParts.size() != 2) {
+                panic("Could not parse workspace package: " + package)
+            }
+            if(packageParts.grab(0) == "*") {
+                panic("Unexpected wildcard: " + package)
+            }
+            Some(WorkspaceRule(
+                packageGroup = packageParts.grab(0)
+                packageName = if(packageParts.grab(1) != "*") {packageParts.grab(1)}
+                location = fixedLocation
+            ))
+        }
+    }
+    Workspace(rules, defaultLocation.else {centralLocation}, packageDirectory.absolute())
+}
+
+extend self: Workspace {
+
+    findPackageLocation(packagePair: PackagePair, version: Version): String {
+        self.rules.find {rule =>
+            rule.packageGroup == packagePair.group && rule.packageName.all {_ == packagePair.name}
+        }.map {rule =>
+            let prefix = if(rule.packageName == None) {packagePair.name + "/"} else {""}
+            if(rule.location.contains(":")) {
+                rule.location + prefix + tarGzName(packagePair, version)
+            } else {
+                self.packageDirectory + "/" + rule.location + prefix
+            }
+        }.else {
+            self.defaultLocation + packagePair.group + "/" + packagePair.name + "/" +
+            tarGzName(packagePair, version)
+        }
+    }
+
+}
+
+tarGzName(packagePair: PackagePair, version: Version): String {
+    packagePair.group + "_" + packagePair.name + "_" +
+    version.major + "_" + version.minor + "_" + version.patch + ".tar.gz"
+}