firefly-compiler 0.4.24 → 0.4.26

package/compiler/Builder.ff

@@ -6,6 +6,7 @@ import Compiler
 import Unification
 import Dependencies
 import JsEmitter
+import ModuleCache
 import LspHook
 
 build(
@@ -18,6 +19,7 @@ build(
     tempPath: Path
     jsOutputPath: Path
     printMeasurements: Bool
+    moduleCache: ModuleCache
 ): Unit {
 
     if(tempPath.exists()) {tempPath.delete()}
@@ -34,6 +36,7 @@ build(
             jsPathFile
             resolvedDependencies
             Map.empty()
+            moduleCache
             lspHook = LspHook.disabled()
         )
         compiler.emit(mainPackage, mainModule, isMainModule = True)
@@ -81,6 +84,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)
     )
 }
 
@@ -90,8 +94,11 @@ check(
     path: Path
     mustContain: Option[String]
     virtualFiles: Map[String, String]
+    cache: ModuleCache
+    newVersion: Int
     lspHook: LspHook
     infer: Bool
+    checkDependencies: Bool
 ): List[CompileError] {
     let packages = path.isDirectory().{
         | True => findPackageFiles(path, mustContain)
@@ -109,6 +116,7 @@ check(
             resolvedDependencies.packagePaths.add(PackagePair("ff", "core"), fireflyPath.slash("core"))
         }
         let fixedResolvedDependencies = resolvedDependencies.ResolvedDependencies(packagePaths = fixedPackagePaths)
+        let newCache = cache.without(newVersion, path)
         let compiler = Compiler.make(
             EmitBuild
             system.mainTask() 
@@ -116,9 +124,13 @@ check(
             package.root.slash(".firefly").slash("temporary")
             fixedResolvedDependencies
             virtualFiles
+            newCache
             lspHook
         )
-        package.files.each {file =>
+        let files = if(checkDependencies) {package.files} else {
+            package.files.filter {!_.contains([".firefly", "dependencies"])}
+        }
+        files.each {file =>
             let localFile = file.base()
             try {
                 if(infer) {
@@ -131,6 +143,7 @@ check(
                 errors.push(c)
             } grab()
         }
+        cache.mergeVersions(compiler.cache)
     }
     errors.drain()
 

package/compiler/Compiler.ff

@@ -1,5 +1,6 @@
 import Syntax
 import Tokenizer
+import ModuleCache
 import Parser
 import Resolver
 import Deriver
@@ -17,12 +18,8 @@ capability Compiler(
     packagePaths: Map[PackagePair, Path]
     singleFilePackages: Set[PackagePair]
     virtualFiles: Map[String, String]
+    cache: ModuleCache
     lspHook: LspHook
-    mutable parsedModules: Map[String, Module]
-    mutable resolvedModules: Map[String, Module]
-    mutable derivedModules: Map[String, Module]
-    mutable inferredModules: Map[String, Module]
-    mutable emittedModules: Set[String]
     mutable phaseDurationDelta: Duration
     phaseDurations: Array[Pair[String, Duration]]
 )
@@ -34,6 +31,7 @@ make(
     jsOutputPath: Path
     resolvedDependencies: ResolvedDependencies
     virtualFiles: Map[String, String]
+    cache: ModuleCache
     lspHook: LspHook
 ): Compiler {
     Compiler(
@@ -44,12 +42,8 @@ make(
         packagePaths = resolvedDependencies.packagePaths
         singleFilePackages = resolvedDependencies.singleFilePackages
         virtualFiles = virtualFiles
+        cache = cache
         lspHook = lspHook
-        parsedModules = Map.empty()
-        resolvedModules = Map.empty()
-        derivedModules = Map.empty()
-        inferredModules = Map.empty()
-        emittedModules = Set.empty()
         phaseDurationDelta = Duration(0.0)
         phaseDurations = [].toArray()
     )
@@ -66,7 +60,6 @@ coreImports: List[DImport] =
         "AssetSystem"
         "Atomic"
         "Bool"
-        "Box"
         "BrowserSystem"
         "Buffer"
         "BuildSystem"
@@ -139,14 +132,9 @@ extend self: Compiler {
     }
 
     parse(packagePair: PackagePair, moduleName: String, importedAt: Option[Location]): Module {
+        self.cache.cacheParsedModule(self.packagePaths, packagePair, moduleName): path => 
         let packageName = packagePair.groupName()
-        self.parsedModules.get(packageName + ":" + moduleName).else:
         self.measure("Parse", packagePair, moduleName):
-        let packagePath = self.packagePaths.get(packagePair).else {
-            panic("Internal error - package path missing: " + packagePair.groupName())
-        }
-        let file = moduleName + ".ff"
-        let path = packagePath.slash(file)
         let code = self.virtualFiles.get(path.absolute()).else {
             importedAt.each {at => if(!path.exists()) {
                 throw(CompileError(at, "Imported module not found: " + packageName + "/" + moduleName))
@@ -155,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, file, tokens, self.emitTarget != EmitBrowser, self.lspHook)
+        let parser = Parser.make(packagePair, path.base(), tokens, self.emitTarget != EmitBrowser, self.lspHook)
         let module = if(self.singleFilePackages.contains(packagePair)) {
             parser.parseModuleWithPackageInfo().module
         } else {
@@ -164,7 +152,6 @@ extend self: Compiler {
         let result = module.Module(
             imports = [...coreImports, ...module.imports]
         )
-        self.parsedModules = self.parsedModules.add(packageName + ":" + moduleName, result)
         result
     }
 
@@ -180,34 +167,25 @@ extend self: Compiler {
     }
 
     resolve(packagePair: PackagePair, moduleName: String): Module {
-        let packageName = packagePair.groupName()
-        self.resolvedModules.get(packageName + ":" + moduleName).else:
+        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.make(packagePair, moduleName, self.lspHook)
-        let result = resolver.resolveModule(module, otherModules)
-
-        self.resolvedModules = self.resolvedModules.add(packageName + ":" + moduleName, result)
-        result
+        resolver.resolveModule(module, otherModules)
     }
 
     derive(packagePair: PackagePair, moduleName: String): Module {
-        let packageName = packagePair.groupName()
-        self.derivedModules.get(packageName + ":" + moduleName).else:
+        self.cache.cacheDerivedModule(self.packagePaths, packagePair, moduleName): path => 
         self.measure("Derive", packagePair, moduleName):
 
         let module = self.resolve(packagePair, moduleName)
-        let result = Deriver.make().deriveModule(module)
-
-        self.derivedModules = self.derivedModules.add(packageName + ":" + moduleName, result)
-        result
+        Deriver.make().deriveModule(module)
     }
 
     infer(packagePair: PackagePair, moduleName: String): Module {
-        let packageName = packagePair.groupName()
-        self.inferredModules.get(packageName + ":" + moduleName).else:
+        self.cache.cacheInferredModule(self.packagePaths, packagePair, moduleName): path => 
         self.measure("Infer", packagePair, moduleName):
 
         let module = self.derive(packagePair, moduleName)
@@ -216,17 +194,12 @@ extend self: Compiler {
         }
         let inference = Inference.make([module, ...otherModules], self.lspHook)
         let inferredModule = inference.inferModule(module, otherModules)
-        let result = Dictionaries.make([module, ...otherModules]).processModule(inferredModule, otherModules)
-
-        self.inferredModules = self.inferredModules.add(packageName + ":" + moduleName, result)
-        result
+        Dictionaries.make([module, ...otherModules]).processModule(inferredModule, otherModules)
     }
 
     emit(packagePair: PackagePair, moduleName: String, isMainModule: Bool): Unit {
-        let packageName = packagePair.groupName()
-        if(self.emittedModules.contains(packageName + ":" + moduleName)) {} else:
+        self.cache.cacheEmittedModule(self.packagePaths, packagePair, moduleName): path => 
         self.measure("Emit", packagePair, moduleName):
-        self.emittedModules = self.emittedModules.add(packageName + ":" + moduleName)
 
         let module = self.infer(packagePair, moduleName)
         let otherModules = self.imports(module).map {i =>

package/compiler/Main.ff

@@ -8,6 +8,7 @@ import Builder
 import Dependencies
 import JsEmitter
 import Inference
+import ModuleCache
 import LspHook
 
 data MainCommand {
@@ -54,6 +55,7 @@ main(system: NodeSystem): Unit {
             tempPath = system.path(".firefly").slash("temporary")
             jsOutputPath = system.path(".firefly").path("output").path(targetName)
             printMeasurements = False
+            moduleCache = ModuleCache.empty(0)
         )
     }
 
@@ -85,7 +87,18 @@ main(system: NodeSystem): Unit {
             importAndRun(fireflyPath, "build", resolvedDependencies.mainPackagePair, localMainFile, [])
 
         | CheckCommand(filePath) => 
-            let errors = Builder.check(system, fireflyPath, system.path(filePath), None, Map.empty(), LspHook.disabled(), True)
+            let errors = Builder.check(
+                system = system
+                fireflyPath = fireflyPath
+                path = system.path(filePath)
+                mustContain = None
+                virtualFiles = Map.empty()
+                cache = ModuleCache.empty(1)
+                newVersion = 0
+                lspHook = LspHook.disabled() 
+                infer = True
+                checkDependencies = False
+            )
             if(!errors.isEmpty()) {throw(CompileErrors(errors.distinct()))}
 
         | BootstrapCommand =>
@@ -108,6 +121,7 @@ main(system: NodeSystem): Unit {
                 tempPath = workingDirectory.slash("output").slash("temporary")
                 jsOutputPath = workingDirectory.slash("output").slash("js")
                 printMeasurements = True
+                moduleCache = ModuleCache.empty(0)
             )
     }
 

package/compiler/ModuleCache.ff

@@ -0,0 +1,160 @@
+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]
+)
+
+empty(version: Int): ModuleCache {
+    ModuleCache(
+        version = version
+        parsedModules = Map.empty()
+        resolvedModules = Map.empty()
+        derivedModules = Map.empty()
+        inferredModules = Map.empty()
+        emittedModules = Map.empty()
+    )
+}
+
+extend self: ModuleCache {
+    
+    remove(paths: List[Path]) {
+        if(!paths.isEmpty()):
+        let keys = paths.map {_.absolute()}
+        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)
+    }
+    
+    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)
+}

package/core/Map.ff

@@ -41,6 +41,14 @@ extend self[K: Order, V]: Map[K, V] {
         }
         Map(result)
     }
+    
+    removeList(keys: List[K]): Map[K, V] {
+        mutable result = self.redBlack
+        keys.each {k =>
+            result = RbMap.delete(k, result)
+        }
+        Map(result)
+    }
 
     pairs(): List[Pair[K, V]] { // TODO: Remove this method (use toList)
         self.toList()

package/core/Path.ff

@@ -119,6 +119,10 @@ extend self: Path {
         go(Some(self), parts.reverse())
     }
 
+    contains(parts: List[String]): Bool {
+        self.endsWith(parts) || self.parent().any {_.contains(parts)}
+    }
+
     base(): String
         target node async """
             import * as path from 'path'

package/experimental/bidirectional/Bidi.ff

@@ -0,0 +1,88 @@
+data Expression {
+    EVariable(name: String)
+    EApply(function: Expression, argument: Expression)
+    ELambda(variable: String, body: Expression)
+    EAnnotate(type: Type, expression: Expression)
+}
+
+data Type(name: String, typeArguments: List[Type])
+
+data Context(variables: Map[String, Type])
+
+data TypeError(message: String)
+
+
+check(c0: Context, t0: Type, e0: Expression): Unit {
+    e0.{
+        | ELambda(x1, e1) => 
+            t0.{
+                | Type("Function", [t2, t3]) =>
+                    let c2 = c0.Context(variables = c0.variables.add(x1, t2))
+                    check(c2, t3, e1)
+                    t3
+                | _ =>
+                    throw(TypeError("Function type not expected here"))
+            }
+        | _ => 
+            let t1 = infer(c0, e0)
+            checkSame(t0, t1)
+    }
+}
+
+
+infer(c0: Context, e0: Expression): Type {
+    e0.{
+        | EVariable(x1) => 
+            c0.variables.get(x1).{
+                | None => 
+                    throw(TypeError("Variable not in scope: " + x1))
+                | Some(t1) => 
+                    t1
+            }
+        | EApply(e1, e2) => 
+            let t1 = infer(c0, e1)
+            t1.{
+                | Type("Function", [t2, t3]) =>
+                    check(c0, t2, e2)
+                    t3
+                | _ =>
+                    throw(TypeError("Can't call non-functions"))
+            }
+        | ELambda _ => 
+            throw(TypeError("Lambda functions must be explicitly typed"))
+        | EAnnotate(t1, e1) =>
+            checkType(t1)
+            check(c0, t1, e1)
+            t1
+    }
+}
+
+
+checkSame(t1: Type, t2: Type): Unit {
+    if(t1.name != t2.name) {throw(TypeError("Type mismatch: " + t1.name + " vs. " + t2.name + ""))}
+    if(t1.typeArguments.size() != t2.typeArguments.size()) {
+        throw(TypeError(
+            "Type mismatch: " + t1.name + " with " + 
+            t1.typeArguments.size() + " vs. " + t2.typeArguments.size() +
+            " type arguments"
+        ))
+    }
+    t1.typeArguments.zip(t2.typeArguments).each {| Pair(t3, t4) =>
+        checkSame(t3, t4)
+    }
+}
+
+
+checkType(t0: Type): Unit {
+    t0.{
+        | Type("Function", [t1, t2]) =>
+            checkType(t1)
+            checkType(t2)
+        | Type("Bool", []) =>
+        | Type("Int", []) =>
+        | Type("List", [t1]) =>
+            checkType(t1)
+        | _ =>
+            throw(TypeError("Type is not well formed"))
+    }
+}