firefly-compiler 0.4.27 → 0.4.28

package/compiler/Builder.ff

@@ -93,6 +93,7 @@ check(
     fireflyPath: Path
     path: Path
     mustContain: Option[String]
+    skipFiles: Set[String]
     virtualFiles: Map[String, String]
     cache: ModuleCache
     newVersion: Int
@@ -101,7 +102,7 @@ check(
     checkDependencies: Bool
 ): List[CompileError] {
     let packages = path.isDirectory().{
-        | True => findPackageFiles(path, mustContain)
+        | True => findPackageFiles(path, mustContain, skipFiles)
         | False {path.endsWith([".firefly", "package.ff"])} => [PackageFiles(path.parent().grab(), Some(path), [])]
         | False => [PackageFiles(path.parent().grab(), None, [path])]
     }
@@ -156,8 +157,12 @@ capability PackageFiles(
 )
 
 
-findPackageFiles(path: Path, mustContain: Option[String]): List[PackageFiles] {
-    let files = findFireflyFiles(path, mustContain)
+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
@@ -174,17 +179,21 @@ findPackageFiles(path: Path, mustContain: Option[String]): List[PackageFiles] {
     [...multiFileProjects, ...singleFileProjects]
 }
 
-findFireflyFiles(path: Path, mustContain: Option[String]): List[Path] {
+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" && mustContain.all {s => 
+        file.extension() == ".ff" && !skipFiles.contains(file.absolute()) && mustContain.all {s => 
             file.readText().contains(s)
         }
     }
-    [...fireflyFiles, ...directories.flatMap {findFireflyFiles(_, mustContain)}]
+    [...fireflyFiles, ...directories.flatMap {findFireflyFiles(_, mustContain, skipFiles)}]
 }
 
 internalCreateExecutable(

package/compiler/Main.ff

@@ -92,6 +92,7 @@ main(system: NodeSystem): Unit {
                 fireflyPath = fireflyPath
                 path = system.path(filePath)
                 mustContain = None
+                skipFiles = Set.empty()
                 virtualFiles = Map.empty()
                 cache = ModuleCache.empty(1)
                 newVersion = 0

package/compiler/ModuleCache.ff

@@ -22,9 +22,8 @@ empty(version: Int): ModuleCache {
 
 extend self: ModuleCache {
     
-    remove(paths: List[Path]) {
-        if(!paths.isEmpty()):
-        let keys = paths.map {_.absolute()}
+    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)
@@ -32,6 +31,25 @@ extend self: ModuleCache {
         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()) {
@@ -157,4 +175,4 @@ modulePath(
     }
     let file = moduleName + ".ff"
     packagePath.slash(file)
-}
+}

package/lsp/Handler.ff

@@ -211,7 +211,7 @@ extend self: Handler {
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         let fireflyPath = system.path(".")
-        let errors = self.check(system, fireflyPath, path, None, self.virtualFiles, version, LspHook.disabled(), True)
+        let errors = self.check(system, fireflyPath, path, None, Set.empty(), self.virtualFiles, version, LspHook.disabled(), True)
         let diagnostics = errors.map {| CompileError(at, message) => 
             let tokenLocation = self.findToken(system, at)
             Json.object()
@@ -230,7 +230,7 @@ extend self: Handler {
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
         let fireflyPath = system.path(".")
-        let errors = self.check(system, fireflyPath, path, None, self.virtualFiles, version, LspHook.disabled(), True)
+        let errors = self.check(system, fireflyPath, path, None, Set.empty(), self.virtualFiles, version, LspHook.disabled(), True)
         let diagnostics = errors.map {| CompileError(at, message) => 
             let tokenLocation = self.findToken(system, at)
             Json.object()
@@ -295,7 +295,7 @@ extend self: Handler {
 
     handleWorkspaceSymbol(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
         let query = parameters.grab("query").grabString()
-        let files = self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(self.rootPath.grab(), None)}
+        let files = self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(self.rootPath.grab(), None, Set.empty())}
         let symbols = files.flatMap {file => 
             let documentSymbols = self.getDocumentSymbolsWithCache(system, file)
             let workspaceSymbols = documentSymbols.flatMap {SymbolHandler.documentToWorkspaceSymbols(_, None)}
@@ -314,9 +314,9 @@ extend self: Handler {
         let creates = parameters.grab("changes").grabArray().filter {_.field("type").grabInt() == 1}
         let changes = parameters.grab("changes").grabArray().filter {_.field("type").grabInt() == 2}
         let deletes = parameters.grab("changes").grabArray().filter {_.field("type").grabInt() == 3}
-        self.moduleCache.remove(creates.map {_.field("uri").grabString()}.map {system.pathFromUrl(_)})
-        self.moduleCache.remove(changes.map {_.field("uri").grabString()}.map {system.pathFromUrl(_)})
-        self.moduleCache.remove(deletes.map {_.field("uri").grabString()}.map {system.pathFromUrl(_)})
+        creates.map {_.field("uri").grabString()}.each {self.moduleCache.invalidate(system.pathFromUrl(_).absolute())}
+        changes.map {_.field("uri").grabString()}.each {self.moduleCache.invalidate(system.pathFromUrl(_).absolute())}
+        deletes.map {_.field("uri").grabString()}.each {self.moduleCache.invalidate(system.pathFromUrl(_).absolute())}
         let diagnostics = self.handleClearDiagnostic(system, [Pair("files", Json.array(deletes))].toMap())
         diagnostics.map {Pair("textDocument/publishDiagnostics", _)}
     }
@@ -326,6 +326,7 @@ extend self: Handler {
         let path = system.pathFromUrl(uri)
         self.responseCache = Map.empty()
         self.fileSymbolsCache = self.fileSymbolsCache.remove(path.absolute())
+        self.moduleCache.invalidate(path.absolute())
         let contentChanges = parameters.grab("contentChanges").grabArray()
         if(contentChanges.size() != 1) {throw(LanguageServerException("Expected a single element in contentChanges"))} else:
         let contentChange = contentChanges.grab(0)
@@ -343,7 +344,7 @@ extend self: Handler {
     handleHover(system: NodeSystem, targetAt: Location, goToDefinition: Bool, version: Int): ResultOrError {
         let lspHook = LspHook.make(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
         let path = system.path(targetAt.file)
-        let errors = self.check(system, self.fireflyPath, path, None, self.virtualFiles, version, lspHook, True)
+        let errors = self.check(system, self.fireflyPath, path, None, Set.empty(), self.virtualFiles, version, lspHook, True)
         errors.each {| CompileError(at, message) => 
             Log.trace("handleHover check error: " + message)
         }
@@ -365,7 +366,7 @@ extend self: Handler {
         )
         let lspHook = LspHook.make(at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False)
         let path = system.path(completionAt.file)
-        let errors = self.check(system, self.fireflyPath, path, None, self.virtualFiles, version, lspHook, True)
+        let errors = self.check(system, self.fireflyPath, path, None, Set.empty(), self.virtualFiles, version, lspHook, True)
         errors.each {| CompileError(at, message) => 
             Log.trace("handleCompletion check error: " + message)
         }        
@@ -399,7 +400,7 @@ extend self: Handler {
             | ParseArgumentHook h => 
                 let callLspHook = LspHook.make(at = Some(h.callAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
                 let path = system.path(cursorAt.file)
-                let errors = self.check(system, self.fireflyPath, path, None, self.virtualFiles, version, callLspHook, True)
+                let errors = self.check(system, self.fireflyPath, path, None, Set.empty(), self.virtualFiles, version, callLspHook, True)
                 errors.each {| CompileError(at, message) => 
                     Log.trace("handleSignatureHelp check 2 error: " + message)
                 }        
@@ -464,7 +465,7 @@ extend self: Handler {
     ): Option[List[TokenLocation]] {
         let temporaryLspHook = LspHook.make(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
         let path = system.path(targetAt.file)
-        let errors = self.check(system, self.fireflyPath, path, None, self.virtualFiles, version, temporaryLspHook, True)
+        let errors = self.check(system, self.fireflyPath, path, None, Set.empty(), self.virtualFiles, version, temporaryLspHook, True)
         errors.each {| CompileError(at, message) => 
             Log.trace("findReferences first check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
         }  
@@ -496,6 +497,16 @@ extend self: Handler {
             qualifiedName.split('.').grabLast().split('_').grabLast()
         }
 
+        function extractModuleName(qualifiedName: String): String {
+            qualifiedName.split('/').grabLast().takeWhile {c => c != '.' || c == '_'}
+        }
+
+        function extractPackagePair(qualifiedName: String): PackagePair {
+            let group = qualifiedName.split(':').grabFirst()
+            let name = qualifiedName.split(':').grabLast().takeWhile {_ != '/'}
+            PackagePair(group, name)
+        }
+
         definedAtList.first().{
             | Some(definition) =>
                 let lspHook = LspHook.make(at = None, definedAt = Some(definition.at), insertIdentifier = False, trackSymbols = False)
@@ -505,7 +516,19 @@ extend self: Handler {
                 Log.trace("findReferences definition: " + Show.show(definition))
                 mustContain.each {Log.trace("mustContain: " + _)}
                 
-                let errors = self.check(system, self.fireflyPath, path, mustContain, self.virtualFiles, version, lspHook, True, False)
+                let skipFiles = if(definition.name.contains(":")) {
+                    let list = self.moduleCache.filesNotImporting(extractPackagePair(definition.name), extractModuleName(definition.name))
+                    list.toSet()
+                } else {
+                    self.moduleCache.parsedModules.get(definition.at.file).map {| Pair(module, _) =>
+                        let list = self.moduleCache.filesNotImporting(module.packagePair, module.file.dropLast(3))
+                        list.toSet()
+                    }.else {
+                        Log.trace("No skip list due to unqualified definition.name: " + definition.name)
+                        Set.empty()
+                    }
+                }
+                let errors = self.check(system, self.fireflyPath, path, mustContain, skipFiles, self.virtualFiles, version, lspHook, True, False)
                 errors.each {| CompileError(at, message) => 
                     Log.trace("findReferences second check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
                 }
@@ -646,6 +669,7 @@ extend self: Handler {
         fireflyPath: Path
         path: Path
         mustContain: Option[String]
+        skipFiles: Set[String]
         virtualFiles: Map[String, String]
         newModuleCacheVersion: Int
         lspHook: LspHook
@@ -657,6 +681,7 @@ extend self: Handler {
             fireflyPath
             path
             mustContain
+            skipFiles
             virtualFiles
             self.moduleCache
             newModuleCacheVersion

package/output/js/ff/compiler/Builder.mjs

@@ -166,10 +166,10 @@ return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.pac
 }))(resolvedDependencies_), ff_core_Option.None(), ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/temporary"), ff_core_Path.Path_slash(ff_core_NodeSystem.NodeSystem_path(system_, ".firefly/output"), target_), false, ff_compiler_ModuleCache.empty_(0))
 }
 
-export function check_(system_, fireflyPath_, path_, mustContain_, virtualFiles_, cache_, newVersion_, lspHook_, infer_, checkDependencies_) {
+export function check_(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, newVersion_, lspHook_, infer_, checkDependencies_) {
 const packages_ = (((_1) => {
 if(_1) {
-return ff_compiler_Builder.findPackageFiles_(path_, mustContain_)
+return ff_compiler_Builder.findPackageFiles_(path_, mustContain_, skipFiles_)
 }
 if(!_1 && ff_core_Path.Path_endsWith(path_, [".firefly", "package.ff"])) {
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab(ff_core_Path.Path_parent(path_)), ff_core_Option.Some(path_), [])]
@@ -221,8 +221,8 @@ ff_compiler_ModuleCache.ModuleCache_mergeVersions(cache_, compiler_.cache_)
 return ff_core_Array.Array_drain(errors_)
 }
 
-export function findPackageFiles_(path_, mustContain_) {
-const files_ = ff_compiler_Builder.findFireflyFiles_(path_, mustContain_);
+export function findPackageFiles_(path_, mustContain_, skipFiles_) {
+const files_ = ff_compiler_Builder.findFireflyFiles_(path_, mustContain_, skipFiles_);
 const split_ = ff_core_List.List_partition(files_, ((_w1) => {
 return ff_core_Path.Path_endsWith(_w1, [".firefly", "package.ff"])
 }));
@@ -243,7 +243,7 @@ return ff_compiler_Builder.PackageFiles(projectRoot_, ff_core_Option.None(), [fi
 return [...multiFileProjects_, ...singleFileProjects_]
 }
 
-export function findFireflyFiles_(path_, mustContain_) {
+export function findFireflyFiles_(path_, mustContain_, skipFiles_) {
 const split_ = ff_core_List.List_partition(ff_core_Stream.Stream_toList(ff_core_Path.Path_entries(path_)), ((_w1) => {
 return ff_core_Path.PathEntry_isDirectory(_w1)
 }));
@@ -257,12 +257,12 @@ return (((c_ === 46) || ff_core_Char.Char_isAsciiLower(c_)) || ff_core_Char.Char
 const fireflyFiles_ = ff_core_List.List_filter(ff_core_List.List_map(split_.second_, ((_w1) => {
 return ff_core_Path.PathEntry_path(_w1)
 })), ((file_) => {
-return ((ff_core_Path.Path_extension(file_) === ".ff") && ff_core_Option.Option_all(mustContain_, ((s_) => {
+return (((ff_core_Path.Path_extension(file_) === ".ff") && (!ff_core_Set.Set_contains(skipFiles_, ff_core_Path.Path_absolute(file_), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String))) && ff_core_Option.Option_all(mustContain_, ((s_) => {
 return ff_core_String.String_contains(ff_core_Path.Path_readText(file_), s_)
 })))
 }));
 return [...fireflyFiles_, ...ff_core_List.List_flatMap(directories_, ((_w1) => {
-return ff_compiler_Builder.findFireflyFiles_(_w1, mustContain_)
+return ff_compiler_Builder.findFireflyFiles_(_w1, mustContain_, skipFiles_)
 }))]
 }
 
@@ -355,10 +355,10 @@ return ff_compiler_Dependencies.ResolvedDependencies(_c.mainPackagePair_, _c.pac
 }))(resolvedDependencies_), ff_core_Option.None(), (await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/temporary", $task)), (await ff_core_Path.Path_slash$((await ff_core_NodeSystem.NodeSystem_path$(system_, ".firefly/output", $task)), target_, $task)), false, ff_compiler_ModuleCache.empty_(0), $task))
 }
 
-export async function check_$(system_, fireflyPath_, path_, mustContain_, virtualFiles_, cache_, newVersion_, lspHook_, infer_, checkDependencies_, $task) {
+export async function check_$(system_, fireflyPath_, path_, mustContain_, skipFiles_, virtualFiles_, cache_, newVersion_, lspHook_, infer_, checkDependencies_, $task) {
 const packages_ = (await ((async (_1, $task) => {
 if(_1) {
-return (await ff_compiler_Builder.findPackageFiles_$(path_, mustContain_, $task))
+return (await ff_compiler_Builder.findPackageFiles_$(path_, mustContain_, skipFiles_, $task))
 }
 if(!_1 && (await ff_core_Path.Path_endsWith$(path_, [".firefly", "package.ff"], $task))) {
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(path_, $task))), ff_core_Option.Some(path_), [])]
@@ -410,8 +410,8 @@ ff_compiler_ModuleCache.ModuleCache_mergeVersions(cache_, compiler_.cache_)
 return ff_core_Array.Array_drain(errors_)
 }
 
-export async function findPackageFiles_$(path_, mustContain_, $task) {
-const files_ = (await ff_compiler_Builder.findFireflyFiles_$(path_, mustContain_, $task));
+export async function findPackageFiles_$(path_, mustContain_, skipFiles_, $task) {
+const files_ = (await ff_compiler_Builder.findFireflyFiles_$(path_, mustContain_, skipFiles_, $task));
 const split_ = (await ff_core_List.List_partition$(files_, (async (_w1, $task) => {
 return (await ff_core_Path.Path_endsWith$(_w1, [".firefly", "package.ff"], $task))
 }), $task));
@@ -432,7 +432,7 @@ return ff_compiler_Builder.PackageFiles(projectRoot_, ff_core_Option.None(), [fi
 return [...multiFileProjects_, ...singleFileProjects_]
 }
 
-export async function findFireflyFiles_$(path_, mustContain_, $task) {
+export async function findFireflyFiles_$(path_, mustContain_, skipFiles_, $task) {
 const split_ = (await ff_core_List.List_partition$((await ff_core_Stream.Stream_toList$((await ff_core_Path.Path_entries$(path_, $task)), $task)), (async (_w1, $task) => {
 return (await ff_core_Path.PathEntry_isDirectory$(_w1, $task))
 }), $task));
@@ -446,12 +446,12 @@ return (((c_ === 46) || ff_core_Char.Char_isAsciiLower(c_)) || ff_core_Char.Char
 const fireflyFiles_ = (await ff_core_List.List_filter$((await ff_core_List.List_map$(split_.second_, (async (_w1, $task) => {
 return (await ff_core_Path.PathEntry_path$(_w1, $task))
 }), $task)), (async (file_, $task) => {
-return (((await ff_core_Path.Path_extension$(file_, $task)) === ".ff") && (await ff_core_Option.Option_all$(mustContain_, (async (s_, $task) => {
+return ((((await ff_core_Path.Path_extension$(file_, $task)) === ".ff") && (!ff_core_Set.Set_contains(skipFiles_, (await ff_core_Path.Path_absolute$(file_, $task)), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String))) && (await ff_core_Option.Option_all$(mustContain_, (async (s_, $task) => {
 return ff_core_String.String_contains((await ff_core_Path.Path_readText$(file_, $task)), s_)
 }), $task)))
 }), $task));
 return [...fireflyFiles_, ...(await ff_core_List.List_flatMap$(directories_, (async (_w1, $task) => {
-return (await ff_compiler_Builder.findFireflyFiles_$(_w1, mustContain_, $task))
+return (await ff_compiler_Builder.findFireflyFiles_$(_w1, mustContain_, skipFiles_, $task))
 }), $task))]
 }
 

package/output/js/ff/compiler/Main.mjs

@@ -212,7 +212,7 @@ return
 }
 if(command_a.CheckCommand) {
 const filePath_ = command_a.filePath_;
-const errors_ = ff_compiler_Builder.check_(system_, fireflyPath_, ff_core_NodeSystem.NodeSystem_path(system_, filePath_), ff_core_Option.None(), ff_core_Map.empty_(), ff_compiler_ModuleCache.empty_(1), 0, ff_compiler_LspHook.disabled_(), true, false);
+const errors_ = ff_compiler_Builder.check_(system_, fireflyPath_, ff_core_NodeSystem.NodeSystem_path(system_, filePath_), ff_core_Option.None(), ff_core_Set.empty_(), ff_core_Map.empty_(), ff_compiler_ModuleCache.empty_(1), 0, ff_compiler_LspHook.disabled_(), true, false);
 if((!ff_core_List.List_isEmpty(errors_))) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(ff_core_List.List_distinct(errors_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_CompileError)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
 }
@@ -459,7 +459,7 @@ return
 }
 if(command_a.CheckCommand) {
 const filePath_ = command_a.filePath_;
-const errors_ = (await ff_compiler_Builder.check_$(system_, fireflyPath_, (await ff_core_NodeSystem.NodeSystem_path$(system_, filePath_, $task)), ff_core_Option.None(), ff_core_Map.empty_(), ff_compiler_ModuleCache.empty_(1), 0, ff_compiler_LspHook.disabled_(), true, false, $task));
+const errors_ = (await ff_compiler_Builder.check_$(system_, fireflyPath_, (await ff_core_NodeSystem.NodeSystem_path$(system_, filePath_, $task)), ff_core_Option.None(), ff_core_Set.empty_(), ff_core_Map.empty_(), ff_compiler_ModuleCache.empty_(1), 0, ff_compiler_LspHook.disabled_(), true, false, $task));
 if((!ff_core_List.List_isEmpty(errors_))) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileErrors(ff_core_List.List_distinct(errors_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_CompileError)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)})
 }

package/output/js/ff/compiler/ModuleCache.mjs

@@ -147,11 +147,8 @@ const file_ = (moduleName_ + ".ff");
 return (await ff_core_Path.Path_slash$(packagePath_, file_, $task))
 }
 
-export function ModuleCache_remove(self_, paths_) {
-if((!ff_core_List.List_isEmpty(paths_))) {
-const keys_ = ff_core_List.List_map(paths_, ((_w1) => {
-return ff_core_Path.Path_absolute(_w1)
-}));
+export function ModuleCache_remove(self_, keys_) {
+if((!ff_core_List.List_isEmpty(keys_))) {
 self_.parsedModules_ = ff_core_Map.Map_removeList(self_.parsedModules_, keys_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
 self_.resolvedModules_ = ff_core_Map.Map_removeList(self_.resolvedModules_, keys_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
 self_.derivedModules_ = ff_core_Map.Map_removeList(self_.derivedModules_, keys_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
@@ -160,6 +157,44 @@ self_.emittedModules_ = ff_core_Map.Map_removeList(self_.emittedModules_, keys_,
 }
 }
 
+export function ModuleCache_invalidate(self_, key_) {
+ff_core_Option.Option_each(ff_core_Map.Map_get(self_.parsedModules_, key_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ((_1) => {
+{
+const module_ = _1.first_;
+const moduleName_ = ff_core_String.String_dropLast(module_.file_, 3);
+ff_compiler_ModuleCache.ModuleCache_remove(self_, [key_]);
+ff_core_Map.Map_each(self_.parsedModules_, ((_1, _2) => {
+{
+const k_ = _1;
+const m_ = _2.first_;
+if(ff_core_List.List_any(m_.imports_, ((i_) => {
+return (ff_compiler_Syntax.ff_core_Equal_Equal$ff_compiler_Syntax_PackagePair.equals_(i_.package_, module_.packagePair_) && (i_.file_ === moduleName_))
+}))) {
+ff_compiler_ModuleCache.ModuleCache_remove(self_, [k_])
+}
+return
+}
+}), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)
+return
+}
+}))
+}
+
+export function ModuleCache_filesNotImporting(self_, packagePair_, moduleName_) {
+return ff_core_List.List_collect(ff_core_Map.Map_toList(self_.parsedModules_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ((_1) => {
+{
+const k_ = _1.first_;
+const m_ = _1.second_.first_;
+if((!ff_core_List.List_any(m_.imports_, ((i_) => {
+return (ff_compiler_Syntax.ff_core_Equal_Equal$ff_compiler_Syntax_PackagePair.equals_(i_.package_, packagePair_) && (i_.file_ === moduleName_))
+})))) {
+return ff_core_Option.Some(k_)
+} else return ff_core_Option.None()
+return
+}
+}))
+}
+
 export function ModuleCache_without(self_, newVersion_, path_) {
 const key_ = ff_core_Path.Path_absolute(path_);
 if(ff_core_Path.Path_isFile(path_)) {
@@ -285,11 +320,8 @@ ff_core_Error.Error_rethrow(error_)
 }
 }
 
-export async function ModuleCache_remove$(self_, paths_, $task) {
-if((!ff_core_List.List_isEmpty(paths_))) {
-const keys_ = (await ff_core_List.List_map$(paths_, (async (_w1, $task) => {
-return (await ff_core_Path.Path_absolute$(_w1, $task))
-}), $task));
+export async function ModuleCache_remove$(self_, keys_, $task) {
+if((!ff_core_List.List_isEmpty(keys_))) {
 self_.parsedModules_ = ff_core_Map.Map_removeList(self_.parsedModules_, keys_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
 self_.resolvedModules_ = ff_core_Map.Map_removeList(self_.resolvedModules_, keys_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
 self_.derivedModules_ = ff_core_Map.Map_removeList(self_.derivedModules_, keys_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
@@ -298,6 +330,44 @@ self_.emittedModules_ = ff_core_Map.Map_removeList(self_.emittedModules_, keys_,
 }
 }
 
+export async function ModuleCache_invalidate$(self_, key_, $task) {
+ff_core_Option.Option_each(ff_core_Map.Map_get(self_.parsedModules_, key_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ((_1) => {
+{
+const module_ = _1.first_;
+const moduleName_ = ff_core_String.String_dropLast(module_.file_, 3);
+ff_compiler_ModuleCache.ModuleCache_remove(self_, [key_]);
+ff_core_Map.Map_each(self_.parsedModules_, ((_1, _2) => {
+{
+const k_ = _1;
+const m_ = _2.first_;
+if(ff_core_List.List_any(m_.imports_, ((i_) => {
+return (ff_compiler_Syntax.ff_core_Equal_Equal$ff_compiler_Syntax_PackagePair.equals_(i_.package_, module_.packagePair_) && (i_.file_ === moduleName_))
+}))) {
+ff_compiler_ModuleCache.ModuleCache_remove(self_, [k_])
+}
+return
+}
+}), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)
+return
+}
+}))
+}
+
+export async function ModuleCache_filesNotImporting$(self_, packagePair_, moduleName_, $task) {
+return ff_core_List.List_collect(ff_core_Map.Map_toList(self_.parsedModules_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ((_1) => {
+{
+const k_ = _1.first_;
+const m_ = _1.second_.first_;
+if((!ff_core_List.List_any(m_.imports_, ((i_) => {
+return (ff_compiler_Syntax.ff_core_Equal_Equal$ff_compiler_Syntax_PackagePair.equals_(i_.package_, packagePair_) && (i_.file_ === moduleName_))
+})))) {
+return ff_core_Option.Some(k_)
+} else return ff_core_Option.None()
+return
+}
+}))
+}
+
 export async function ModuleCache_without$(self_, newVersion_, path_, $task) {
 const key_ = (await ff_core_Path.Path_absolute$(path_, $task));
 if((await ff_core_Path.Path_isFile$(path_, $task))) {

package/package.json

@@ -4,7 +4,7 @@
   "description": "Firefly compiler",
   "author": "Firefly team",
   "license": "MIT",
-  "version": "0.4.27",
+  "version": "0.4.28",
   "repository": {
       "type": "git",
       "url": "https://github.com/Ahnfelt/firefly-boot"

package/vscode/language-configuration.json

@@ -37,6 +37,20 @@
         "decreaseIndentPattern": "^((?!.*?\\/\\*).*\\*/)?\\s*[\\)\\}\\]|].*$"
     }, 
     "onEnterRules": [
+        {
+            "beforeText": "\\.{\\s*$",
+            "action": {
+                "appendText": "| ",
+                "indent": "indent"
+            }
+        },
+        {
+            "beforeText": "^\\s*",
+            "afterText": "\\s*\\|",
+            "action": {
+                "indent": "none"
+            }
+        },
         {
             "beforeText": "({|=>)\\s*$",
             "afterText": "^\\s*}",

package/vscode/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly language support",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.27",
+    "version": "0.4.28",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"