firefly-compiler 0.5.70 → 0.5.72

package/.vscode/settings.json

@@ -1,5 +1,5 @@
 {
     "editor.suggest.showWords": false,
-    "firefly.trace.server": "verbose",
+    "firefly.trace.server": "messages",
     "editor.trimAutoWhitespace": false
 }

package/compiler/Builder.ff

@@ -135,7 +135,7 @@ check(
 ): List[CompileError] {
     let packages = path.isDirectory().{
         | False {path.endsWith([".firefly", "package.ff"])} => [PackageFiles(path.parent().grab(), Some(path), [])]
-        | True => findPackageFilesForDirectory(path, mustContain, skipFiles)
+        | True => findPackageFilesForDirectory(path, virtualFiles, mustContain, skipFiles)
         | False => findPackageFilesForFile(path).toList()
     }
     let errors = Array.new()
@@ -213,10 +213,11 @@ findPackageFilesForFile(file: Path): Option[PackageFiles] {
 
 findPackageFilesForDirectory(
     directory: Path
+    virtualFiles: Map[String, String]
     mustContain: Option[String]
     skipFiles: Set[String]
 ): List[PackageFiles] {
-    let files = findFireflyFiles(directory, mustContain, skipFiles)
+    let files = findFireflyFiles(directory, virtualFiles, mustContain, skipFiles)
     let split = files.partition {_.endsWith([".firefly", "package.ff"])}
     let packageFiles = split.first
     mutable singleFiles = split.second
@@ -236,6 +237,7 @@ findPackageFilesForDirectory(
 
 findFireflyFiles(
     path: Path
+    virtualFiles: Map[String, String]
     mustContain: Option[String]
     skipFiles: Set[String]
 ): List[Path] {
@@ -246,11 +248,14 @@ findFireflyFiles(
         c == '.' || c.isAsciiLower() || c.isAsciiDigit()
     }}
     let fireflyFiles = files.map {_.path()}.filter {file => 
-        file.extension() == ".ff" && !skipFiles.contains(file.absolute()) && mustContain.all {s => 
-            file.readText().contains(s)
-        }
+        file.extension() == ".ff" && !skipFiles.contains(file.absolute()) && (
+            file.endsWith([".firefly", "package.ff"]) || mustContain.all {s => 
+                let code = virtualFiles.get(file.absolute()).else {file.readText()}
+                code.contains(s)
+            }
+        )
     }
-    [...fireflyFiles, ...relevantDirectories.flatMap {findFireflyFiles(_, mustContain, skipFiles)}]
+    [...fireflyFiles, ...relevantDirectories.flatMap {findFireflyFiles(_, virtualFiles, mustContain, skipFiles)}]
 }
 
 internalCreateExecutable(

package/compiler/Dependencies.ff

@@ -145,7 +145,7 @@ extend self: Dependencies {
 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).else {
+    let packageInfo = self.loadPackageInfo(Syntax.scriptPackagePair, path).else {
         if(!path.exists()) {
             throw(CompileError(Location(path.absolute(), 1, 1), "File not found"))
         } else {

package/compiler/Main.ff

@@ -150,7 +150,7 @@ main(system: NodeSystem): Unit {
             let columns = filePaths.flatMap {filePath =>
                 let path = system.path(filePath)
                 let code = path.readText()
-                let packagePair = PackagePair("script", "script")
+                let packagePair = Syntax.scriptPackagePair
                 let moduleKey = ModuleKey(packagePair, [], path.base().removeLast(".ff").grab())
                 let tokens = Tokenizer.tokenize(path.absolute(), code, None, False)
                 let parser = Parser.new(moduleKey, tokens, True, LspHook.disabled())

package/compiler/Syntax.ff

@@ -47,6 +47,8 @@ extend self: PackagePair {
     }
 }
 
+scriptPackagePair: PackagePair = PackagePair("script", "script")
+
 data ModuleKey(
     packagePair: PackagePair
     folders: List[String]

package/core/String.ff

@@ -150,8 +150,8 @@ extend self: String {
         self!->startsWith(prefix, offset)?
     }
 
-    endsWith(prefix: String): Bool {
-        self!->endsWith(prefix)?
+    endsWith(suffix: String): Bool {
+        self!->endsWith(suffix)?
     }
 
     removeFirst(prefix: String): Option[String] {

package/experimental/foldertest/Root.ff

@@ -1,10 +1,3 @@
-import a.A
-
-nodeMain(system: NodeSystem) {
-    Log.trace("Hello Root")
-    A.functionA()
+foo(abe: Int): Int {
+    bb
 }
-
-functionRoot() {
-    Log.trace("function Root")
-}

package/experimental/foldertest/findinfolder/FindInFolder.ff

@@ -0,0 +1,3 @@
+myFunction2(xxx: Int): Int {
+    xxx
+}

package/lsp/CompletionHandler.ff

@@ -240,7 +240,7 @@ completionsToJson(completions: List[CompletionInfo]): Json {
 importCompletion(moduleKeys: List[ModuleKey]): List[CompletionInfo] {
     moduleKeys.map {moduleKey =>
         let label = moduleKey.folders.map {_ + "."}.join() + moduleKey.name
-        let extra = if(moduleKey.packagePair.name == "script" && moduleKey.packagePair.group == "script") {
+        let extra = if(moduleKey.packagePair == Syntax.scriptPackagePair) {
             ""
         } else {
             " from " + moduleKey.packagePair.groupName(":")
@@ -374,9 +374,7 @@ completion(
 
 makeAutoimportCompletion(info: ImportSymbolInfo, importLine: Int, name: String, isType: Bool): CompletionInfo {
     let moduleName = info.moduleKey.folders.map {_ + "."}.join() + info.moduleKey.name
-    let fromName = if(
-        info.moduleKey.packagePair.name == "script" && info.moduleKey.packagePair.group == "script"
-    ) {
+    let fromName = if(info.moduleKey.packagePair == Syntax.scriptPackagePair) {
         ""
     } else {
         info.moduleKey.packagePair.groupName(":")

package/lsp/Handler.ff

@@ -76,7 +76,6 @@ extend self: Handler {
                 let diagnostics = self.handleFocusDiagnostic(system, parameters, version)
                 [Pair("textDocument/publishDiagnostics", diagnostics)]
             | "custom/focusDocument" => 
-                self.importSymbolsCache = Pair("", [])
                 let diagnostics = self.handleFocusDiagnostic(system, parameters, version)
                 [Pair("textDocument/publishDiagnostics", diagnostics)]
             | "workspace/didRenameFiles" =>
@@ -283,7 +282,7 @@ extend self: Handler {
             let lspHook = LspHook.new(at = None, definedAt = None, insertIdentifier = False, trackSymbols = True)
             let code = self.virtualFiles.get(path.absolute()).else {path.readText()}
             let tokens = Tokenizer.tokenize(path.absolute(), code, None, True)
-            let dummyModuleKey = ModuleKey(PackagePair("script", "script"), [], path.base())
+            let dummyModuleKey = ModuleKey(Syntax.scriptPackagePair, [], path.base())
             let parser = Parser.new(dummyModuleKey, tokens, False, lspHook)
             parser.parseModuleWithPackageInfo()
             SymbolHandler.readAllSymbols(lspHook.results())
@@ -317,7 +316,9 @@ extend self: Handler {
         let files = if(rootPath.isFile()) {
             [rootPath]
         } else {
-            self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(rootPath, None, Set.new())}
+            self.printTime(system.mainTask(), "findFireflyFiles") {
+                Builder.findFireflyFiles(rootPath, self.virtualFiles, None, Set.new())
+            }
         }
         let root = if(rootPath.isFile()) {rootPath.parent().grab()} else {rootPath}
         let query = parameters.grab("query").grabString()
@@ -339,9 +340,14 @@ 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}
-        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())}
+        function invalidate(url: String) {
+            let path = system.pathFromUrl(url)
+            if(self.importSymbolsCache.first != path.absolute()) {self.importSymbolsCache = Pair("", [])}
+            self.moduleCache.invalidate(path.absolute())
+        }
+        creates.map {_.field("uri").grabString()}.each {invalidate(_)}
+        changes.map {_.field("uri").grabString()}.each {invalidate(_)}
+        deletes.map {_.field("uri").grabString()}.each {invalidate(_)}
         let diagnostics = self.handleClearDiagnostic(system, [Pair("files", Json.array(deletes))].toMap())
         diagnostics.map {Pair("textDocument/publishDiagnostics", _)}
     }
@@ -358,6 +364,7 @@ extend self: Handler {
     handleDidChange(system: NodeSystem, parameters: Map[String, Json]): Unit {
         let uri = parameters.grab("textDocument").field("uri").grabString()
         let path = system.pathFromUrl(uri)
+        if(self.importSymbolsCache.first != path.absolute()) {self.importSymbolsCache = Pair("", [])}
         self.responseCache = Map.new()
         self.fileSymbolsCache = self.fileSymbolsCache.remove(path.absolute())
         self.moduleCache.invalidate(path.absolute())
@@ -428,7 +435,7 @@ extend self: Handler {
         try {
             let code = self.virtualFiles.get(cursorAt.file).else {system.path(cursorAt.file).readText()}
             let tokens = Tokenizer.tokenize(cursorAt.file, code, None, True)
-            let dummyModuleKey = ModuleKey(PackagePair("script", "script"), [], "<LSP>")
+            let dummyModuleKey = ModuleKey(Syntax.scriptPackagePair, [], "<LSP>")
             let parser = Parser.new(dummyModuleKey, tokens, False, lspHook)
             parser.parseModuleWithPackageInfo()
         } tryCatch {| CompileError(at, message), error =>
@@ -484,7 +491,6 @@ extend self: Handler {
             | Some([]) => Result(Json.null().write())
             | Some([first, ...] @ tokens) =>
                 let oldName = first.raw
-                Log.trace("Rename '" + oldName + "' to '" + newName + "'")
 
                 // TODO findReferences returns some bad tokens
                 let goodTokens = tokens.filter {_.raw == oldName}
@@ -514,8 +520,8 @@ extend self: Handler {
         version: Int
     ): Option[List[TokenLocation]] {
         let temporaryLspHook = LspHook.new(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
-        let path = system.path(targetAt.file)
-        let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, temporaryLspHook, True)
+        let targetPath = system.path(targetAt.file)
+        let errors = self.check(system, self.fireflyPath, targetPath, None, Set.new(), self.virtualFiles, version, temporaryLspHook, True)
         errors.each {| CompileError(at, message) => 
             Log.trace("findReferences first check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
         }  
@@ -543,6 +549,9 @@ extend self: Handler {
             | h => None
         }.filter {pair => !pair.at.file.endsWith(">")}
             
+        Log.trace("findReferences("+Show.show(targetAt)+")")
+        Log.trace("definedAtList: " + Show.show(definedAtList))
+            
         function unqualify(qualifiedName: String): String {
             qualifiedName.split('.').grabLast().split('_').grabLast()
         }
@@ -561,10 +570,8 @@ extend self: Handler {
             | Some(definition) =>
                 let lspHook = LspHook.new(at = None, definedAt = Some(definition.at), insertIdentifier = False, trackSymbols = False)
                 let localCheck = local || definition.local
-                let path = if(localCheck) {system.path(targetAt.file)} else {self.rootPath.else {system.path(targetAt.file)}}
+                let checkPath = if(localCheck) {targetPath} else {self.rootPath.else {targetPath}}
                 let mustContain = Some(definition.name).filter {_ => !localCheck}.map(unqualify)
-                Log.trace("findReferences definition: " + Show.show(definition))
-                mustContain.each {Log.trace("mustContain: " + _)}
                 
                 let skipFiles = if(definition.name.contains(":")) {
                     let list = self.moduleCache.filesNotImporting(extractModuleKey(definition.name))
@@ -577,8 +584,8 @@ extend self: Handler {
                         Log.trace("No skip list due to unqualified definition.name: " + definition.name)
                         Set.new()
                     }
-                }
-                let errors = self.check(system, self.fireflyPath, path, mustContain, skipFiles, self.virtualFiles, version, lspHook, True)
+                }.remove(targetPath.absolute())
+                let errors = self.check(system, self.fireflyPath, checkPath, mustContain, skipFiles, self.virtualFiles, version, lspHook, True)
                 errors.each {| CompileError(at, message) => 
                     Log.trace("findReferences second check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
                 }
@@ -599,8 +606,6 @@ extend self: Handler {
                     !at.file.endsWith(">") &&
                     (includeDeclaration || at != definition.at)
                 }
-                
-                //referencesResult.each {Log.trace(Show.show(_))}
 
                 let clientLocations = referencesResult.addAll(
                     if(includeDeclaration) {[definition.at]} else {[]}
@@ -635,7 +640,7 @@ extend self: Handler {
                 }.toOption()
             }
             let symbols = nonCore.flatMap {| Pair(packagePair, packagePath) =>
-                let packageFiles = Builder.findPackageFilesForDirectory(packagePath, None, Set.new())
+                let packageFiles = Builder.findPackageFilesForDirectory(packagePath, self.virtualFiles, None, Set.new())
                 packageFiles.flatMap {_.files.collect {file => 
                     parseModule(packagePair, file).map: module =>
                     let typeNames = module.types.map {_.name}
@@ -651,7 +656,7 @@ extend self: Handler {
         let imports = try {
             let code = self.virtualFiles.get(modulePath.absolute()).else {modulePath.readText()}
             let tokens = Tokenizer.tokenize(modulePath.absolute(), code, Some(lspHook.at), True)
-            let parser = Parser.new(ModuleKey(PackagePair("", ""), [], ""), tokens, True, lspHook)
+            let parser = Parser.new(ModuleKey(Syntax.scriptPackagePair, [], ""), tokens, True, lspHook)
             tokens.each {token => 
                 if(token.is(LKeyword) && token.rawIs4("import", "include", "package", "dependency")) {
                     importLine = token.startLine + 1
@@ -789,3 +794,7 @@ extend self: Handler {
     }
 
 }
+
+foo(bb: Int): Int {
+    bb
+}

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

@@ -214,7 +214,7 @@ 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_), [])]
 }
 if(_1) {
-return ff_compiler_Builder.findPackageFilesForDirectory_(path_, mustContain_, skipFiles_)
+return ff_compiler_Builder.findPackageFilesForDirectory_(path_, virtualFiles_, mustContain_, skipFiles_)
 }
 {
 return ff_core_Option.Option_toList(ff_compiler_Builder.findPackageFilesForFile_(path_))
@@ -315,8 +315,8 @@ return ff_compiler_Builder.PackageFiles(projectRoot_, packageFile_, [file_])
 } else return ff_core_Option.None()
 }
 
-export function findPackageFilesForDirectory_(directory_, mustContain_, skipFiles_) {
-const files_ = ff_compiler_Builder.findFireflyFiles_(directory_, mustContain_, skipFiles_);
+export function findPackageFilesForDirectory_(directory_, virtualFiles_, mustContain_, skipFiles_) {
+const files_ = ff_compiler_Builder.findFireflyFiles_(directory_, virtualFiles_, mustContain_, skipFiles_);
 const split_ = ff_core_List.List_partition(files_, ((_w1) => {
 return ff_core_Path.Path_endsWith(_w1, [".firefly", "package.ff"])
 }));
@@ -338,7 +338,7 @@ return ff_compiler_Builder.PackageFiles(projectRoot_, ff_core_Option.None(), [fi
 return [...multiFileProjects_, ...singleFileProjects_]
 }
 
-export function findFireflyFiles_(path_, mustContain_, skipFiles_) {
+export function findFireflyFiles_(path_, virtualFiles_, 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)
 }));
@@ -354,12 +354,15 @@ 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(files_, ((_w1) => {
 return ff_core_Path.PathEntry_path(_w1)
 })), ((file_) => {
-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 (((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_Path.Path_endsWith(file_, [".firefly", "package.ff"]) || ff_core_Option.Option_all(mustContain_, ((s_) => {
+const code_ = ff_core_Option.Option_else(ff_core_Map.Map_get(virtualFiles_, ff_core_Path.Path_absolute(file_), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), (() => {
+return ff_core_Path.Path_readText(file_)
+}));
+return ff_core_String.String_contains(code_, s_)
+}))))
 }));
 return [...fireflyFiles_, ...ff_core_List.List_flatMap(relevantDirectories_, ((_w1) => {
-return ff_compiler_Builder.findFireflyFiles_(_w1, mustContain_, skipFiles_)
+return ff_compiler_Builder.findFireflyFiles_(_w1, virtualFiles_, mustContain_, skipFiles_)
 }))]
 }
 
@@ -493,7 +496,7 @@ if(!_1 && (await ff_core_Path.Path_endsWith$(path_, [".firefly", "package.ff"],
 return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab((await ff_core_Path.Path_parent$(path_, $task))), ff_core_Option.Some(path_), [])]
 }
 if(_1) {
-return (await ff_compiler_Builder.findPackageFilesForDirectory_$(path_, mustContain_, skipFiles_, $task))
+return (await ff_compiler_Builder.findPackageFilesForDirectory_$(path_, virtualFiles_, mustContain_, skipFiles_, $task))
 }
 {
 return ff_core_Option.Option_toList((await ff_compiler_Builder.findPackageFilesForFile_$(path_, $task)))
@@ -594,8 +597,8 @@ return ff_compiler_Builder.PackageFiles(projectRoot_, packageFile_, [file_])
 } else return ff_core_Option.None()
 }
 
-export async function findPackageFilesForDirectory_$(directory_, mustContain_, skipFiles_, $task) {
-const files_ = (await ff_compiler_Builder.findFireflyFiles_$(directory_, mustContain_, skipFiles_, $task));
+export async function findPackageFilesForDirectory_$(directory_, virtualFiles_, mustContain_, skipFiles_, $task) {
+const files_ = (await ff_compiler_Builder.findFireflyFiles_$(directory_, virtualFiles_, 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));
@@ -617,7 +620,7 @@ return ff_compiler_Builder.PackageFiles(projectRoot_, ff_core_Option.None(), [fi
 return [...multiFileProjects_, ...singleFileProjects_]
 }
 
-export async function findFireflyFiles_$(path_, mustContain_, skipFiles_, $task) {
+export async function findFireflyFiles_$(path_, virtualFiles_, 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));
@@ -633,12 +636,15 @@ 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$(files_, (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") && (!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)))
+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_Path.Path_endsWith$(file_, [".firefly", "package.ff"], $task)) || (await ff_core_Option.Option_all$(mustContain_, (async (s_, $task) => {
+const code_ = (await ff_core_Option.Option_else$(ff_core_Map.Map_get(virtualFiles_, (await ff_core_Path.Path_absolute$(file_, $task)), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), (async ($task) => {
+return (await ff_core_Path.Path_readText$(file_, $task))
+}), $task));
+return ff_core_String.String_contains(code_, s_)
+}), $task))))
 }), $task));
 return [...fireflyFiles_, ...(await ff_core_List.List_flatMap$(relevantDirectories_, (async (_w1, $task) => {
-return (await ff_compiler_Builder.findFireflyFiles_$(_w1, mustContain_, skipFiles_, $task))
+return (await ff_compiler_Builder.findFireflyFiles_$(_w1, virtualFiles_, mustContain_, skipFiles_, $task))
 }), $task))]
 }
 

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

@@ -123,7 +123,7 @@ return {mainPackagePair_, packages_, packagePaths_, singleFilePackages_};
 export function process_(fetch_, dependencyLock_, path_) {
 const workspace_ = ff_compiler_Workspace.loadWorkspace_(path_);
 const self_ = ff_compiler_Dependencies.Dependencies(workspace_, ff_core_List.List_toMap([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toMap([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toSet([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair));
-const packageInfo_ = ff_core_Option.Option_else(ff_compiler_Dependencies.Dependencies_loadPackageInfo(self_, ff_compiler_Syntax.PackagePair("script", "script"), path_), (() => {
+const packageInfo_ = ff_core_Option.Option_else(ff_compiler_Dependencies.Dependencies_loadPackageInfo(self_, ff_compiler_Syntax.scriptPackagePair_, path_), (() => {
 if((!ff_core_Path.Path_exists(path_, false, false, false))) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(ff_compiler_Syntax.Location(ff_core_Path.Path_absolute(path_), 1, 1), "File not found"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 } else {
@@ -167,7 +167,7 @@ tar_.extract({file: tarGzPath_.absolutePath_, cwd: path_.absolutePath_, strict:
 export async function process_$(fetch_, dependencyLock_, path_, $task) {
 const workspace_ = (await ff_compiler_Workspace.loadWorkspace_$(path_, $task));
 const self_ = ff_compiler_Dependencies.Dependencies(workspace_, ff_core_List.List_toMap([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toMap([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ff_core_List.List_toSet([], ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair));
-const packageInfo_ = (await ff_core_Option.Option_else$((await ff_compiler_Dependencies.Dependencies_loadPackageInfo$(self_, ff_compiler_Syntax.PackagePair("script", "script"), path_, $task)), (async ($task) => {
+const packageInfo_ = (await ff_core_Option.Option_else$((await ff_compiler_Dependencies.Dependencies_loadPackageInfo$(self_, ff_compiler_Syntax.scriptPackagePair_, path_, $task)), (async ($task) => {
 if((!(await ff_core_Path.Path_exists$(path_, false, false, false, $task)))) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(ff_compiler_Syntax.Location((await ff_core_Path.Path_absolute$(path_, $task)), 1, 1), "File not found"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 } else {

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

@@ -246,7 +246,7 @@ const filePaths_ = command_a.filePaths_;
 const columns_ = ff_core_List.List_flatMap(filePaths_, ((filePath_) => {
 const path_ = ff_core_NodeSystem.NodeSystem_path(system_, filePath_);
 const code_ = ff_core_Path.Path_readText(path_);
-const packagePair_ = ff_compiler_Syntax.PackagePair("script", "script");
+const packagePair_ = ff_compiler_Syntax.scriptPackagePair_;
 const moduleKey_ = ff_compiler_Syntax.ModuleKey(packagePair_, [], ff_core_Option.Option_grab(ff_core_String.String_removeLast(ff_core_Path.Path_base(path_), ".ff")));
 const tokens_ = ff_compiler_Tokenizer.tokenize_(ff_core_Path.Path_absolute(path_), code_, ff_core_Option.None(), false);
 const parser_ = ff_compiler_Parser.new_(moduleKey_, tokens_, true, ff_compiler_LspHook.disabled_());
@@ -650,7 +650,7 @@ const filePaths_ = command_a.filePaths_;
 const columns_ = (await ff_core_List.List_flatMap$(filePaths_, (async (filePath_, $task) => {
 const path_ = (await ff_core_NodeSystem.NodeSystem_path$(system_, filePath_, $task));
 const code_ = (await ff_core_Path.Path_readText$(path_, $task));
-const packagePair_ = ff_compiler_Syntax.PackagePair("script", "script");
+const packagePair_ = ff_compiler_Syntax.scriptPackagePair_;
 const moduleKey_ = ff_compiler_Syntax.ModuleKey(packagePair_, [], ff_core_Option.Option_grab(ff_core_String.String_removeLast((await ff_core_Path.Path_base$(path_, $task)), ".ff")));
 const tokens_ = ff_compiler_Tokenizer.tokenize_((await ff_core_Path.Path_absolute$(path_, $task)), code_, ff_core_Option.None(), false);
 const parser_ = ff_compiler_Parser.new_(moduleKey_, tokens_, true, ff_compiler_LspHook.disabled_());

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

@@ -361,7 +361,7 @@ export function Version(at_, major_, minor_, patch_) {
 return {at_, major_, minor_, patch_};
 }
 
-
+export const scriptPackagePair_ = ff_compiler_Syntax.PackagePair("script", "script");
 
 export function catchMany_(list_, body_) {
 const errors_ = ff_core_Array.new_();

package/output/js/ff/core/String.mjs

@@ -252,8 +252,8 @@ export function String_startsWith(self_, prefix_, offset_ = 0) {
 return self_.startsWith(prefix_, offset_)
 }
 
-export function String_endsWith(self_, prefix_) {
-return self_.endsWith(prefix_)
+export function String_endsWith(self_, suffix_) {
+return self_.endsWith(suffix_)
 }
 
 export function String_removeFirst(self_, prefix_) {
@@ -514,8 +514,8 @@ export async function String_startsWith$(self_, prefix_, offset_ = 0, $task) {
 return self_.startsWith(prefix_, offset_)
 }
 
-export async function String_endsWith$(self_, prefix_, $task) {
-return self_.endsWith(prefix_)
+export async function String_endsWith$(self_, suffix_, $task) {
+return self_.endsWith(suffix_)
 }
 
 export async function String_removeFirst$(self_, prefix_, $task) {

package/package.json

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

package/vscode/package.json

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

package/experimental/foldertest/a/A.ff

@@ -1,3 +0,0 @@
-functionA() {
-    Log.trace("function A")
-}

package/experimental/foldertest/a/MainA.ff

@@ -1,3 +0,0 @@
-nodeMain(system: NodeSystem) {
-    Log.trace("Hello from a/MainA")
-}