firefly-compiler 0.5.63 → 0.5.64

package/compiler/Main.ff

@@ -28,11 +28,11 @@ main(system: NodeSystem): Unit {
     let fireflyPath = detectFireflyPath(system)
 
     function buildScript(
-        mainFile: String
+        mainPath: Path
         mainPackagePair: PackagePair
         emitTarget: EmitTarget
         resolvedDependencies: ResolvedDependencies
-    ) {
+    ): ModuleKey {
         let fixedPackagePaths = if(resolvedDependencies.packagePaths.contains(PackagePair("ff", "core"))) {
             resolvedDependencies.packagePaths
         } else {
@@ -47,11 +47,13 @@ main(system: NodeSystem): Unit {
             | EmitBrowser => "browser"
             | EmitExecutable => "executable"
         }
+        let folders = mainPath.parent().grab().relativeListTo(fixedPackagePaths.grab(mainPackagePair))
+        let name = mainPath.base().removeLast(".ff").grab()
+        let moduleKey = ModuleKey(mainPackagePair, folders, name)
         Builder.build(
             system = system
             emitTarget = emitTarget
-            mainPackage = mainPackagePair
-            mainModules = [mainFile]
+            mainModules = [moduleKey]
             resolvedDependencies = resolvedDependencies.ResolvedDependencies(packagePaths = fixedPackagePaths)
             compilerModulePath = compilerModulePath
             tempPath = system.path(".firefly").slash("temporary")
@@ -59,6 +61,7 @@ main(system: NodeSystem): Unit {
             printMeasurements = False
             moduleCache = ModuleCache.new(0)
         )
+        moduleKey
     }
 
     function runCommand(command: MainCommand) {
@@ -66,13 +69,13 @@ main(system: NodeSystem): Unit {
             let resolvedDependencies = Dependencies.process(
                 system.httpClient()
                 DependencyLock.new(system.mainTask())
-                system.path(mainFile + ".ff")
+                system.path(mainFile)
             )
             prepareFireflyDirectory(system.path("."))
-            let localMainFile = system.path(mainFile).base()
-            buildScript(localMainFile, resolvedDependencies.mainPackagePair, EmitNode, resolvedDependencies)
-            if(!importAndRun(system, fireflyPath, "node", resolvedDependencies.mainPackagePair, localMainFile, arguments)) {
-                let at = Location(system.path(mainFile + ".ff").absolute(), 1, 1)
+            let mainPath = system.path(mainFile)
+            let moduleKey = buildScript(mainPath, resolvedDependencies.mainPackagePair, EmitNode, resolvedDependencies)
+            if(!importAndRun(system, fireflyPath, "node", moduleKey, arguments)) {
+                let at = Location(system.path(mainFile).absolute(), 1, 1)
                 throw(CompileError(at, "This module does not contain a 'nodeMain' function"))
             }
 
@@ -80,12 +83,12 @@ main(system: NodeSystem): Unit {
             let resolvedDependencies = Dependencies.process(
                 system.httpClient()
                 DependencyLock.new(system.mainTask())
-                system.path(mainFile + ".ff")
+                system.path(mainFile)
             )
             prepareFireflyDirectory(system.path("."))
-            let localMainFile = system.path(mainFile).base()
-            buildScript(mainFile, resolvedDependencies.mainPackagePair, EmitBrowser, resolvedDependencies)
-            bundleForBrowser(system, resolvedDependencies.mainPackagePair, localMainFile)
+            let mainPath = system.path(mainFile)
+            buildScript(mainPath, resolvedDependencies.mainPackagePair, EmitBrowser, resolvedDependencies)
+            bundleForBrowser(system, resolvedDependencies.mainPackagePair, mainPath.base())
 
         | BuildCommand(mainFile) =>
             let resolvedDependencies = Dependencies.process(
@@ -94,11 +97,11 @@ main(system: NodeSystem): Unit {
                 system.path(mainFile + ".ff")
             )
             prepareFireflyDirectory(system.path("."))
-            let localMainFile = system.path(mainFile).base()
-            buildScript(localMainFile, resolvedDependencies.mainPackagePair, EmitBuild, resolvedDependencies)
-            buildScript(localMainFile, resolvedDependencies.mainPackagePair, EmitExecutable, resolvedDependencies)
-            bundleForPkg(system, resolvedDependencies.mainPackagePair, localMainFile)
-            importAndRun(system, fireflyPath, "build", resolvedDependencies.mainPackagePair, localMainFile, [])
+            let mainPath = system.path(mainFile)
+            let moduleKey = buildScript(mainPath, resolvedDependencies.mainPackagePair, EmitBuild, resolvedDependencies)
+            buildScript(mainPath, resolvedDependencies.mainPackagePair, EmitExecutable, resolvedDependencies)
+            bundleForPkg(system, resolvedDependencies.mainPackagePair, mainPath.base())
+            importAndRun(system, fireflyPath, "build", moduleKey, [])
 
         | CheckCommand(filePath) => 
             let errors = Builder.check(
@@ -113,7 +116,6 @@ main(system: NodeSystem): Unit {
                 newVersion = 0
                 lspHook = LspHook.disabled() 
                 infer = True
-                checkDependencies = False
             )
             if(!errors.isEmpty()) {throw(CompileErrors(errors.distinct()))}
 
@@ -123,8 +125,7 @@ main(system: NodeSystem): Unit {
             Builder.build(
                 system = system
                 emitTarget = EmitNode
-                mainPackage = PackagePair("ff", "compiler")
-                mainModules = ["Main"]
+                mainModules = [ModuleKey(PackagePair("ff", "compiler"), [], "Main")]
                 resolvedDependencies = ResolvedDependencies(
                     mainPackagePair = PackagePair("ff", "compiler")
                     packages = [Pair(
@@ -150,8 +151,9 @@ main(system: NodeSystem): Unit {
                 let path = system.path(filePath)
                 let code = path.readText()
                 let packagePair = PackagePair("script", "script")
+                let moduleKey = ModuleKey(packagePair, [], path.base().removeLast(".ff").grab())
                 let tokens = Tokenizer.tokenize(path.absolute(), code, None, False)
-                let parser = Parser.new(packagePair, path.base(), tokens, True, LspHook.disabled())
+                let parser = Parser.new(moduleKey, tokens, True, LspHook.disabled())
                 let module = parser.parseModuleWithPackageInfo().module
                 makeSymbolColumns(module)
             }
@@ -191,11 +193,11 @@ These are the commands:
 
 parseCommandLine(arguments: List[String]): MainCommand {
     | [mainFile, ...mainArguments] {mainFile.removeLast(".ff") | Some(mainName)} =>
-        RunCommand(mainName, mainArguments)
+        RunCommand(mainFile, mainArguments)
     | ["run", ...runArguments] =>
         runArguments.{
             | [mainFile, ...mainArguments] {mainFile.removeLast(".ff") | Some(mainName)} =>
-                RunCommand(mainName, mainArguments)
+                RunCommand(mainFile, mainArguments)
             | _ => throw(CommandLineError(
                 "You must specify a Firefly file (.ff) as first argument to run." + usageString
             ))
@@ -203,7 +205,7 @@ parseCommandLine(arguments: List[String]): MainCommand {
     | ["browser", ...browserArguments] =>
         browserArguments.{
             | [mainFile] {mainFile.removeLast(".ff") | Some(mainName)} =>
-                BrowserCommand(mainName)
+                BrowserCommand(mainFile)
             | [_, _, ...] => throw(CommandLineError(
                 "You must only specify a single argument to browser." + usageString
             ))
@@ -214,7 +216,7 @@ parseCommandLine(arguments: List[String]): MainCommand {
     | ["build", ...buildArguments] =>
         buildArguments.{
             | [mainFile] {mainFile.removeLast(".ff") | Some(mainName)} =>
-                BuildCommand(mainName)
+                BuildCommand(mainFile)
             | [_, _, ...] => throw(CommandLineError(
                 "You must only specify a single argument to build." + usageString
             ))
@@ -266,15 +268,14 @@ importAndRun(
     system: NodeSystem
     fireflyPath: Path
     target: String
-    packagePair: PackagePair
-    mainFile: String
+    moduleKey: ModuleKey
     arguments: List[String]
 ): Bool {
     let process = Js.await(Js.dynamicImport("process"))
     let cwd = process->cwd()
     let workingDirectory = if(cwd->indexOf(":") === 1) {"file:///" + cwd?} else {cwd?}
-    let packagePath = packagePair.group + "/" + packagePair.name
-    let runFile = workingDirectory + "/.firefly/output/" + target + "/" + packagePath + "/" + mainFile + ".run.mjs"
+    let packagePath = moduleKey.packagePair.groupName("/")
+    let runFile = workingDirectory + "/.firefly/output/" + target + "/" + packagePath + "/" + moduleKey.importName() + ".run.mjs"
     let runFilePath = if(runFile.contains("://")) {system.pathFromUrl(runFile)} else {system.path(runFile)}
     if(runFilePath.exists()) {
         let main = Js.await(Js.dynamicImport(runFile))
@@ -336,7 +337,7 @@ makeSymbolColumns(module: Module): List[List[String]] {
     let all = [...toplevel, ...types, ...traits]
     all.map {r => 
         let generics = if(r.generics.isEmpty()) {""} else {"[" + r.generics.join(", ") + "]"}
-        let header = (module.file + " " + r.name + generics).trim()
+        let header = (module.moduleKey.importName() + " " + r.name + generics).trim()
         [header, ...r.symbols.sort()]
     }
 }

package/compiler/ModuleCache.ff

@@ -34,19 +34,18 @@ extend self: ModuleCache {
     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}) {
+            if(m.imports.any {i => i.moduleKey == module.moduleKey}) {
                 //Log.trace("Invalidating due to import of invalidated module: " + m.packagePair.groupName() + "/" + m.file)
                 self.remove([k])
             }
         }
     }
     
-    filesNotImporting(packagePair: PackagePair, moduleName: String): List[String] {
+    filesNotImporting(moduleKey: ModuleKey): List[String] {
         self.parsedModules.toList().collect {| Pair(k, Pair(m, _)) =>
-            if(!m.imports.any {i => i.package == packagePair && i.file == moduleName}): k
+            if(!m.imports.any {i => i.moduleKey == moduleKey}): k
         }
     }
     
@@ -86,11 +85,10 @@ extend self: ModuleCache {
     
     cacheParsedModule(
         packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
+        moduleKey: ModuleKey
         body: Path => Module
     ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
+        let path = modulePath(packagePaths, moduleKey)
         self.parsedModules.get(path.absolute()).map {_.first}.else:
         let result = body(path)
         self.parsedModules = self.parsedModules.add(path.absolute(), Pair(result, self.version))
@@ -99,11 +97,10 @@ extend self: ModuleCache {
     
     cacheResolvedModule(
         packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
+        moduleKey: ModuleKey
         body: Path => Module
     ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
+        let path = modulePath(packagePaths, moduleKey)
         self.resolvedModules.get(path.absolute()).map {_.first}.else:
         let result = body(path)
         self.resolvedModules = self.resolvedModules.add(path.absolute(), Pair(result, self.version))
@@ -112,11 +109,10 @@ extend self: ModuleCache {
 
     cacheDerivedModule(
         packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
+        moduleKey: ModuleKey
         body: Path => Module
     ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
+        let path = modulePath(packagePaths, moduleKey)
         self.derivedModules.get(path.absolute()).map {_.first}.else:
         let result = body(path)
         self.derivedModules = self.derivedModules.add(path.absolute(), Pair(result, self.version))
@@ -125,11 +121,10 @@ extend self: ModuleCache {
         
     cacheInferredModule(
         packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
+        moduleKey: ModuleKey
         body: Path => Module
     ): Module {
-        let path = modulePath(packagePaths, packagePair, moduleName)
+        let path = modulePath(packagePaths, moduleKey)
         self.inferredModules.get(path.absolute()).map {_.first}.else:
         let result = body(path)
         self.inferredModules = self.inferredModules.add(path.absolute(), Pair(result, self.version))
@@ -138,12 +133,11 @@ extend self: ModuleCache {
  
     cacheEmittedModule(
         packagePaths: Map[PackagePair, Path]
-        packagePair: PackagePair
-        moduleName: String
+        moduleKey: ModuleKey
         isMainModule: Bool
         body: Path => Unit
     ): Unit {
-        let path = modulePath(packagePaths, packagePair, moduleName)
+        let path = modulePath(packagePaths, moduleKey)
         if(isMainModule || !self.emittedModules.contains(path.absolute())):
         self.emittedModules = self.emittedModules.add(path.absolute(), self.version)
         try {
@@ -168,12 +162,10 @@ mergeVersionedMap[T](oldMap: Map[String, T], newMap: Map[String, T], getVersion:
 
 modulePath(
     packagePaths: Map[PackagePair, Path]
-    packagePair: PackagePair
-    moduleName: String
+    moduleKey: ModuleKey
 ): Path {
-    let packagePath = packagePaths.get(packagePair).else {
-        panic("Internal error - package path missing: " + packagePair.groupName())
+    let packagePath = packagePaths.get(moduleKey.packagePair).else {
+        panic("Internal error - package path missing: " + moduleKey.packagePair.groupName())
     }
-    let file = moduleName + ".ff"
-    packagePath.slash(file)
+    moduleKey.path(packagePath)
 }

package/compiler/Parser.ff

@@ -4,8 +4,7 @@ import Syntax
 import LspHook
 
 class Parser(
-    packagePair: PackagePair
-    file: String
+    moduleKey: ModuleKey
     tokens: List[Token]
     end: Token
     targetIsNode: Bool
@@ -18,15 +17,13 @@ class Parser(
 data Poly(generics: List[String], constraints: List[Constraint])
 
 new(
-    packagePair: PackagePair 
-    file: String
+    moduleKey: ModuleKey
     tokens: List[Token]
     targetIsNode: Bool
     lspHook: LspHook
 ): Parser {
     Parser(
-        packagePair = packagePair
-        file = file
+        moduleKey = moduleKey
         tokens = tokens
         end = tokens.grabLast()
         targetIsNode = targetIsNode
@@ -128,7 +125,7 @@ extend self: Parser {
         } else {
             DPackage(
                 location
-                self.packagePair
+                self.moduleKey.packagePair
                 Version(location, 0, 0, 0)
                 TargetNames(node = self.targetIsNode, browser = !self.targetIsNode)
             )
@@ -175,7 +172,7 @@ extend self: Parser {
             } elseIf {self.current().is(LKeyword) && self.current().rawIs4("data", "class", "capability", "newtype")} {
                 types.push(self.parseTypeDefinition())
             } elseIf {self.current().is(LKeyword) && self.current().rawIs("import")} {
-                imports.push(self.parseImportDefinition(self.packagePair))
+                imports.push(self.parseImportDefinition(self.moduleKey.packagePair))
             } elseIf {self.current().is(LKeyword) && self.current().rawIs("include")} {
                 throw(CompileError(self.current().at()
                     "Includes must be at the top of the file or below 'package'"
@@ -195,8 +192,7 @@ extend self: Parser {
         }
 
         Module(
-            file = self.file
-            packagePair = self.packagePair
+            moduleKey = self.moduleKey
             imports = imports.toList()
             lets = lets.toList()
             functions = functions.toList()
@@ -527,7 +523,7 @@ extend self: Parser {
         } else {
             currentPackagePair
         }
-        DImport(fileToken.at(), alias, packagePair, path.toList(), fileToken.raw())
+        DImport(fileToken.at(), alias, ModuleKey(packagePair, path.toList(), fileToken.raw()))
     }
 
     parsePackageDefinition(): DPackage {

package/compiler/Resolver.ff

@@ -26,7 +26,7 @@ data CaseVariable(
     asBound: Option[String]
 )
 
-new(packagePair: PackagePair, moduleName: String, lspHook: LspHook): Resolver {
+new(lspHook: LspHook): Resolver {
     Resolver(
         variables = [].toMap()
         variableLocations = [].toMap()
@@ -54,8 +54,6 @@ extend self: Resolver {
     }
 
     resolveModule(module: Module, otherModules: List[Module]): Module {
-        let moduleNamespace =
-            module.file.replace("\\", "/").reverse().takeWhile {_ != '/'}.reverse().takeWhile {_ != '.'}
         let self2 = self.processImports(module.imports, otherModules)
         let self3 = self2.processDefinitions(module, None)
         
@@ -103,11 +101,11 @@ extend self: Resolver {
     processImports(imports: List[DImport], modules: List[Module]): Resolver {
         mutable resolver = self
         imports.each {import =>
-            modules.find {_.file.dropLast(3) == import.file}.{
+            modules.find {_.moduleKey == import.moduleKey}.{
                 | Some(module) =>
                     resolver = resolver.processDefinitions(module, Some(import.alias))
                 | None =>
-                    throw(CompileError(import.at, "No such module: " + import.file))
+                    throw(CompileError(import.at, "No such module: " + import.moduleKey.importName()))
             }
         }
         resolver
@@ -115,9 +113,7 @@ extend self: Resolver {
 
     processDefinitions(module: Module, importAlias: Option[String]): Resolver {
         function entry(name: String, unqualified: Bool): List[Pair[String, String]] {
-            let full =
-                module.packagePair.groupName() + "/" +
-                module.file.dropLast(3) + "." + name
+            let full = module.moduleKey.qualifiedSymbol(name)
             importAlias.{
                 | None => [Pair(name, full), Pair(full, full)]
                 | Some(alias) {unqualified} => [Pair(alias + "." + name, full), Pair(name, full), Pair(full, full)]
@@ -125,9 +121,10 @@ extend self: Resolver {
             }
         }
         let isCore = // TODO: Extend imports to list unqualified symbols instead of this
-            module.packagePair.group == "ff" &&
-            module.packagePair.name == "core" &&
-            module.file == "Core.ff"
+            module.moduleKey.packagePair.group == "ff" &&
+            module.moduleKey.packagePair.name == "core" &&
+            module.moduleKey.folders == [] &&
+            module.moduleKey.name == "Core"
         let lets = module.lets.flatMap {entry(_.name, isCore)}.toMap()
         let letLocations = module.lets.flatMap {d => entry(d.name, True).map {_.mapSecond {_ => d.at}}}.toMap()
         let functions = module.functions.flatMap {entry(_.signature.name, isCore)}.toMap()

package/compiler/Syntax.ff

@@ -22,18 +22,7 @@ data PackageInfo(
     includes: List[DInclude]
 )
 
-data Module(
-    file: String
-    packagePair: PackagePair
-    imports: List[DImport]
-    types: List[DType]
-    traits: List[DTrait]
-    instances: List[DInstance]
-    extends: List[DExtend]
-    lets: List[DLet]
-    functions: List[DFunction]
-)
-
+// TODO rename to PackageKey
 data PackagePair(
     group: String
     name: String
@@ -43,8 +32,58 @@ extend self: PackagePair {
     groupName(delimiter: String = ":"): String {
         self.group + delimiter + self.name
     }
+    isCore(): Bool {
+        self.group == "ff" &&
+        self.name == "core"
+    }
+    moduleKey(packageRoot: Path, modulePath: Path): Option[ModuleKey] {
+        let parts = modulePath.relativeListTo(packageRoot)
+        let folders = parts.dropLast()
+        parts.last().flatMap {_.removeLast(".ff")}.filter {_ =>
+            folders.all {_.first().any {_.isAsciiLower()}} &&
+            folders.all {_.all {c => c.isAsciiLower() || c.isAsciiDigit()}}
+        }.map: name =>
+        ModuleKey(self, folders, name)
+    }
+}
+
+data ModuleKey(
+    packagePair: PackagePair
+    folders: List[String]
+    name: String
+)
+
+extend self: ModuleKey {
+    // "folder/Module" as in: import folder/Module from group:package
+    importName(): String {
+        self.folders.map {_ + "/"}.join() + self.name
+    }
+    // "C:\myProject\folder\Module.ff"
+    path(packageRoot: Path): Path {
+        let parent = self.folders.foldLeft(packageRoot) {p, f => p.slash(f)}
+        parent.slash(self.name + ".ff")
+    }
+    // "group:package/folder/Module"
+    qualifiedName(): String {
+        self.packagePair.groupName() + "/" + self.importName()
+    }
+    // "ff:core/List.List_map"
+    qualifiedSymbol(symbol: String): String {
+        self.qualifiedName() + "." + symbol
+    }
 }
 
+data Module(
+    moduleKey: ModuleKey
+    imports: List[DImport]
+    types: List[DType]
+    traits: List[DTrait]
+    instances: List[DInstance]
+    extends: List[DExtend]
+    lets: List[DLet]
+    functions: List[DFunction]
+)
+
 data DPackage(
     at: Location
     packagePair: PackagePair
@@ -69,9 +108,7 @@ data TargetNames(
 data DImport(
     at: Location
     alias: String
-    package: PackagePair
-    directory: List[String]
-    file: String
+    moduleKey: ModuleKey
 )
 data DFunction(
     at: Location
@@ -181,8 +218,7 @@ data MatchGuard(
 )
 
 data Dictionary(
-    packagePair: PackagePair
-    moduleName: String
+    moduleKey: ModuleKey
     traitName: String
     typeName: String
     dictionaries: List[Dictionary]

package/compiler/Unification.ff

@@ -17,8 +17,7 @@ data InstanceKey(traitName: String, typeName: String)
 data InstanceValue(
     generics: List[String]
     constraints: List[Constraint]
-    packagePair: PackagePair
-    moduleName: String
+    moduleKey: ModuleKey
     traitName: String
     typeArguments: List[Type]
 )
@@ -34,7 +33,6 @@ new(modules: List[Module], attemptFixes: Bool): Unification {
         Map.new()
         3 // To avoid collision with the parser and resolver
         modules.flatMap {module =>
-            let moduleName = module.file.dropLast(".ff".size())
             module.instances.map {definition =>
                 let typeName = definition.typeArguments.grabFirst().{
                     | TConstructor(_, name, _) => name
@@ -45,8 +43,7 @@ new(modules: List[Module], attemptFixes: Bool): Unification {
                     InstanceValue(
                         generics = definition.generics
                         constraints = definition.constraints
-                        packagePair = module.packagePair
-                        moduleName = moduleName
+                        moduleKey = module.moduleKey
                         traitName = definition.traitName
                         typeArguments = definition.typeArguments
                     )

package/core/BuildSystem.ff

@@ -148,7 +148,7 @@ internalCompile(buildSystem: BuildSystem, mainFiles: List[Path], target: String)
     Js.await(Js.rawIdentifier("$firefly_compiler")->"buildViaBuildSystem_$"(
         buildSystem! 
         internalPath(buildSystem, buildSystem!->"fireflyPath_"?)!
-        mainFiles.map {_.base()}
+        mainFiles!
         target
         Js.currentTask()!
     ))

package/core/Path.ff

@@ -101,10 +101,20 @@ extend self: Path {
     }
 
     relativeTo(path: Path): String {
-        let nodePath = Js.import("path")        
+        let nodePath = Js.import("path")
         nodePath->relative(path.absolutePath, self.absolutePath)?
     }
     
+    relativeListTo(path: Path): List[String] {
+        let nodePath = Js.import("path")
+        let relative = self.relativeTo(path)
+        if(nodePath->sep === "\\") {
+            relative.split('/').flatMap {_.split('\\')}.filter {_ != ""}
+        } else {
+            relative.split('/').filter {_ != ""}
+        }
+    }
+    
     endsWith(parts: List[String]): Bool {
         function go(pathOption: Option[Path], reversed: List[String]): Bool {
             | _, [] => True

package/core/SourceLocation.ff

@@ -26,6 +26,10 @@ extend self: SourceLocation {
         self.location.takeWhile {_ != ':'}.reverse().takeWhile {_ != '/'}.reverse()
     }
     
+    directoryAndModule(): String {
+        self.location.takeWhile {_ != ':'}.reverse().reverse()
+    }
+
     line(): Int {
         self.location.dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ':'}.grabInt()
     }

package/experimental/foldertest/.firefly/package.ff

@@ -0,0 +1 @@
+package foldergroup:test:0.0.0

package/experimental/foldertest/Root.ff

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

package/experimental/foldertest/a/A.ff

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

package/experimental/foldertest/a/MainA.ff

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

package/experimental/tests/TestCancel.ff

@@ -0,0 +1,19 @@
+nodeMain(system: NodeSystem) {
+
+    let task1 = system.mainTask().spawn {task =>
+        Log.debug("Starting task 1")
+        try {
+            while {True} {
+                task.sleep(Duration(0.1))
+            }
+        } catchAny {error =>
+            Log.debug(error.name())
+        }
+    }
+    
+    Log.debug("Aborting task 1")
+    task1.abort()
+    Log.debug("Aborted task 1")
+
+}
+

package/fireflysite/CommunityOverview.ff

@@ -1,6 +1,4 @@
 import Guide
-import CountingButtonDemo
-import MatchingPasswordsDemo
 
 sections(): List[Section] {
     [

package/fireflysite/FrontPage.ff

@@ -1,6 +1,4 @@
 import Guide
-import CountingButtonDemo
-import MatchingPasswordsDemo
 
 sections(): List[Section] {
     [

package/fireflysite/Main.ff

@@ -4,7 +4,7 @@ import Lux from ff:lux
 import Css from ff:lux
 import Guide
 import GettingStarted
-import ExamplesOverview
+import demos.ExamplesOverview
 import PackagesOverview
 import CommunityOverview
 import FrontPage

package/fireflysite/PackagesOverview.ff

@@ -1,6 +1,4 @@
 import Guide
-import CountingButtonDemo
-import MatchingPasswordsDemo
 
 sections(): List[Section] {
     [