firefly-compiler 0.5.63 → 0.5.65

package/compiler/Builder.ff

@@ -13,8 +13,7 @@ import DependencyLock
 build(
     system: NodeSystem
     emitTarget: EmitTarget
-    mainPackage: PackagePair
-    mainModules: List[String]
+    mainModules: List[ModuleKey]
     resolvedDependencies: ResolvedDependencies
     compilerModulePath: Option[Path]
     tempPath: Path
@@ -40,9 +39,7 @@ build(
             moduleCache
             lspHook = LspHook.disabled()
         )
-        mainModules.each {mainModule =>
-            compiler.emit(mainPackage, mainModule, isMainModule = True)
-        }
+        mainModules.each {moduleKey => compiler.emit(moduleKey, isMainModule = True)}
         if(printMeasurements) {compiler.printMeasurements()}
         resolvedDependencies.packagePaths.each {packagePair, packagePath =>
             resolvedDependencies.packages.get(packagePair).each {packageInfo =>
@@ -87,29 +84,33 @@ processNodeModules(system: NodeSystem, jsPathFile: Path, packagePath: Path, info
     }
 }
 
-buildViaBuildSystem(system: NodeSystem, fireflyPath: Path, mainFiles: List[String], target: String) {
-    let mainPaths = mainFiles.map {system.path(_).parent().grab().absolute()}
-    mainPaths.find {_ != mainPaths.grabFirst()}.each {path =>
-        panic("Can't build multiple main files in different directories: " + path + " vs. " + mainPaths.grabFirst())
-    }
+buildViaBuildSystem(system: NodeSystem, fireflyPath: Path, mainFiles: List[Path], target: String) {
     let resolvedDependencies = Dependencies.process(
         system.httpClient()
         DependencyLock.new(system.mainTask())
-        system.path(mainFiles.grabFirst())
+        mainFiles.grabFirst()
     )
     let fixedPackagePaths = if(resolvedDependencies.packagePaths.contains(PackagePair("ff", "core"))) {
         resolvedDependencies.packagePaths
     } else {
         resolvedDependencies.packagePaths.add(PackagePair("ff", "core"), fireflyPath.slash("core"))
     }
+    let packageRoot = resolvedDependencies.packagePaths.grab(resolvedDependencies.mainPackagePair)
+    let mainModuleKeys = mainFiles.map {mainFile =>
+        resolvedDependencies.mainPackagePair.moduleKey(packageRoot, mainFile).else {
+            panic(
+                "Can't build multiple main files in different packages: " + 
+                mainFile.absolute() + " isn't part of " + packageRoot.absolute()
+            )
+        }
+    }
     if(target != "browser") {
         panic("buildViaBuildSystem is currently limited to browser target only - the restriction can be lifted")
     }
     build(
         system = system
         emitTarget = EmitBrowser
-        mainPackage = resolvedDependencies.mainPackagePair
-        mainModules = mainFiles.map {_.dropLast(".ff".size())}
+        mainModules = mainModuleKeys
         resolvedDependencies = resolvedDependencies.ResolvedDependencies(packagePaths = fixedPackagePaths)
         compilerModulePath = None
         tempPath = system.path(".firefly/temporary")
@@ -131,16 +132,16 @@ check(
     newVersion: Int
     lspHook: LspHook
     infer: Bool
-    checkDependencies: Bool
 ): List[CompileError] {
     let packages = path.isDirectory().{
-        | True => findPackageFiles(path, mustContain, skipFiles)
         | False {path.endsWith([".firefly", "package.ff"])} => [PackageFiles(path.parent().grab(), Some(path), [])]
-        | False => [PackageFiles(path.parent().grab(), None, [path])]
+        | True => findPackageFilesForDirectory(path, mustContain, skipFiles)
+        | False => findPackageFilesForFile(path).toList()
     }
     let errors = Array.new()
 
-    packages.filter {!_.files.isEmpty()}.each {package => 
+    let filteredPackages = packages.filter {!_.root.contains([".firefly", "dependencies"])}
+    filteredPackages.filter {!_.files.isEmpty()}.each {package => 
         let firstFile = package.files.grabFirst()
         try {
             Some(Dependencies.process(system.httpClient(), dependencyLock, firstFile))
@@ -168,16 +169,16 @@ check(
             newCache
             lspHook
         )
-        let files = if(checkDependencies) {package.files} else {
-            package.files.filter {!_.contains([".firefly", "dependencies"])}
-        }
-        files.each {file =>
-            let localFile = file.base()
+        package.files.each {file =>
+            let packagePair = resolvedDependencies.mainPackagePair
+            let folders = file.parent().grab().relativeListTo(package.root)
+            let name = file.base().removeLast(".ff").grab()
+            let moduleKey = ModuleKey(packagePair, folders, name)
             try {
                 if(infer) {
-                    compiler.infer(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
+                    compiler.infer(moduleKey)
                 } else {
-                    compiler.resolve(resolvedDependencies.mainPackagePair, localFile.dropLast(".ff".size()))
+                    compiler.resolve(moduleKey)
                 }
             } tryCatch {| CompileError(_, _) @ c, error =>
                 errors.push(c)
@@ -198,12 +199,24 @@ capability PackageFiles(
 )
 
 
-findPackageFiles(
-    path: Path
+findPackageFilesForFile(file: Path): Option[PackageFiles] {
+    if(file.extension() == ".ff"):
+    mutable packageFile = None
+    mutable currentDirectory = file.parent()
+    while {!currentDirectory.isEmpty() && packageFile.isEmpty()} {
+        packageFile = currentDirectory.map {_.slash(".firefly").slash("package.ff")}.filter {_.exists()}
+        currentDirectory = currentDirectory.grab().parent()
+    }
+    let projectRoot = packageFile.map {_.parent().grab().parent().grab()}.else {file.parent().grab()}
+    PackageFiles(projectRoot, packageFile, [file])
+}
+
+findPackageFilesForDirectory(
+    directory: Path
     mustContain: Option[String]
     skipFiles: Set[String]
 ): List[PackageFiles] {
-    let files = findFireflyFiles(path, mustContain, skipFiles)
+    let files = findFireflyFiles(directory, mustContain, skipFiles)
     let split = files.partition {_.endsWith([".firefly", "package.ff"])}
     let packageFiles = split.first
     mutable singleFiles = split.second
@@ -211,7 +224,8 @@ findPackageFiles(
         let projectRoot = packageFile.parent().grab().parent().grab()
         let files = singleFiles.partition {_.isInsideOf(projectRoot)}
         singleFiles = files.second
-        PackageFiles(projectRoot, Some(packageFile), files.first)
+        let packageFiles = files.first
+        PackageFiles(projectRoot, Some(packageFile), packageFiles)
     }
     let singleFileProjects = singleFiles.map {file => 
         let projectRoot = file.parent().grab()
@@ -226,15 +240,17 @@ findFireflyFiles(
     skipFiles: Set[String]
 ): List[Path] {
     let split = path.entries().toList().partition {_.isDirectory()}
-    let directories = split.first.map {_.path()}.filter {_.base().all {c => 
+    let directories = split.first
+    let files = split.second
+    let relevantDirectories = directories.map {_.path()}.filter {_.base().all {c => 
         c == '.' || c.isAsciiLower() || c.isAsciiDigit()
     }}
-    let fireflyFiles = split.second.map {_.path()}.filter {file => 
+    let fireflyFiles = files.map {_.path()}.filter {file => 
         file.extension() == ".ff" && !skipFiles.contains(file.absolute()) && mustContain.all {s => 
             file.readText().contains(s)
         }
     }
-    [...fireflyFiles, ...directories.flatMap {findFireflyFiles(_, mustContain, skipFiles)}]
+    [...fireflyFiles, ...relevantDirectories.flatMap {findFireflyFiles(_, mustContain, skipFiles)}]
 }
 
 internalCreateExecutable(

package/compiler/Compiler.ff

@@ -106,21 +106,19 @@ coreImports: List[DImport] =
         DImport(
             at = Location("<prelude>", 1, 1)
             alias = moduleName
-            package = PackagePair("ff", "core")
-            directory = []
-            file = moduleName
+            moduleKey = ModuleKey(PackagePair("ff", "core"), [], moduleName)
         )
     }
 
 extend self: Compiler {
 
-    measure[T](phase: String, packagePair: PackagePair, moduleName: String, body: () => T): T {
+    measure[T](phase: String, moduleKey: ModuleKey, body: () => T): T {
         let start = Duration(self.task.elapsed().seconds - self.phaseDurationDelta.seconds)
         let result = body()
         let stop = Duration(self.task.elapsed().seconds - self.phaseDurationDelta.seconds)
         let duration = Duration(stop.seconds - start.seconds)
         self.phaseDurationDelta = Duration(self.phaseDurationDelta.seconds + duration.seconds)
-        let text = phase + " " + packagePair.groupName() + "/" + moduleName
+        let text = phase + " " + moduleKey.qualifiedName()
         self.phaseDurations.push(Pair(text, duration))
         result
     }
@@ -134,20 +132,19 @@ 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.measure("Parse", packagePair, moduleName):
+    parse(moduleKey: ModuleKey, importedAt: Option[Location]): Module {
+        self.cache.cacheParsedModule(self.packagePaths, moduleKey): path => 
+        self.measure("Parse", moduleKey):
         let code = self.virtualFiles.get(path.absolute()).else {
             importedAt.each {at => if(!path.exists()) {
-                throw(CompileError(at, "Imported module not found: " + packageName + "/" + moduleName))
+                throw(CompileError(at, "Imported module not found: " + moduleKey.importName()))
             }}
             path.readText()
         }
         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.new(packagePair, path.base(), tokens, self.emitTarget != EmitBrowser, self.lspHook)
-        let module = if(self.singleFilePackages.contains(packagePair)) {
+        let parser = Parser.new(moduleKey, tokens, self.emitTarget != EmitBrowser, self.lspHook)
+        let module = if(self.singleFilePackages.contains(moduleKey.packagePair)) {
             parser.parseModuleWithPackageInfo().module
         } else {
             parser.parseModuleWithoutPackageInfo()
@@ -160,63 +157,61 @@ extend self: Compiler {
 
     imports(module: Module): List[Module] {
         module.imports.map {import =>
-            let newPackagePair = import.package
-            let newModuleName = import.directory.map {_ + "/"}.join("") + import.file
+            let newPackagePair = import.moduleKey.packagePair
             if(!self.packagePaths.contains(newPackagePair)) {
                 throw(CompileError(import.at, "Missing dependency declaration for: " + newPackagePair.groupName()))
             }
             try {
-                self.parse(newPackagePair, newModuleName, Some(import.at))
+                self.parse(import.moduleKey, Some(import.at))
             } tryCatch {| CompileError(_, _) @ e, error =>
-                let newError = CompileError(import.at, "Parse error in imported module: " + import.package.groupName() + "/" + newModuleName)
+                let newError = CompileError(import.at, "Parse error in imported module: " + import.moduleKey.importName())
                 throw(CompileErrors([e, newError]))
             } catch {| CompileErrors(compileErrors), error =>
-                let newError = CompileError(import.at, "Parse errors in imported module: " + import.package.groupName() + "/" + newModuleName)
+                let newError = CompileError(import.at, "Parse errors in imported module: " + import.moduleKey.importName())
                 throw(CompileErrors([...compileErrors, newError]))
             }
         }
     }
 
-    resolve(packagePair: PackagePair, moduleName: String): Module {
-        self.cache.cacheResolvedModule(self.packagePaths, packagePair, moduleName): path => 
-        self.measure("Resolve", packagePair, moduleName):
+    resolve(moduleKey: ModuleKey): Module {
+        self.cache.cacheResolvedModule(self.packagePaths, moduleKey): path => 
+        self.measure("Resolve", moduleKey):
 
-        let module = self.parse(packagePair, moduleName, None)
+        let module = self.parse(moduleKey, None)
         let otherModules = self.imports(module)
-        let resolver = Resolver.new(packagePair, moduleName, self.lspHook)
+        let resolver = Resolver.new(self.lspHook)
         resolver.resolveModule(module, otherModules)
     }
 
-    derive(packagePair: PackagePair, moduleName: String): Module {
-        self.cache.cacheDerivedModule(self.packagePaths, packagePair, moduleName): path => 
-        self.measure("Derive", packagePair, moduleName):
+    derive(moduleKey: ModuleKey): Module {
+        self.cache.cacheDerivedModule(self.packagePaths, moduleKey): path => 
+        self.measure("Derive", moduleKey):
 
-        let module = self.resolve(packagePair, moduleName)
+        let module = self.resolve(moduleKey)
         Deriver.new().deriveModule(module)
     }
 
-    infer(packagePair: PackagePair, moduleName: String): Module {
-        self.cache.cacheInferredModule(self.packagePaths, packagePair, moduleName): path => 
-        self.measure("Infer", packagePair, moduleName):
+    infer(moduleKey: ModuleKey): Module {
+        self.cache.cacheInferredModule(self.packagePaths, moduleKey): path => 
+        self.measure("Infer", moduleKey):
 
-        let module = self.derive(packagePair, moduleName)
+        let module = self.derive(moduleKey)
         let otherModules = self.imports(module).map {i =>
-            self.derive(i.packagePair, i.file.dropLast(".ff".size()))
+            self.derive(i.moduleKey)
         }
         let inference = Inference.new([module, ...otherModules], self.lspHook)
         let inferredModule = inference.inferModule(module, otherModules)
         Dictionaries.new([module, ...otherModules]).processModule(inferredModule, otherModules)
     }
 
-    emit(packagePair: PackagePair, moduleName: String, isMainModule: Bool): Unit {
-        self.cache.cacheEmittedModule(self.packagePaths, packagePair, moduleName, isMainModule): path => 
-        self.measure("Emit", packagePair, moduleName):
+    emit(moduleKey: ModuleKey, isMainModule: Bool): Unit {
+        self.cache.cacheEmittedModule(self.packagePaths, moduleKey, isMainModule): path => 
+        self.measure("Emit", moduleKey):
 
-        let module = self.infer(packagePair, moduleName)
+        let module = self.infer(moduleKey)
         let otherModules = self.imports(module).map {i =>
-            let newModuleName = i.file.dropLast(".ff".size())
-            self.emit(i.packagePair, newModuleName, isMainModule = False)
-            self.infer(i.packagePair, newModuleName)
+            self.emit(i.moduleKey, isMainModule = False)
+            self.infer(i.moduleKey)
         }
 
         let allModules = [module, ...otherModules]
@@ -225,22 +220,22 @@ extend self: Compiler {
             emitTarget = self.emitTarget
             isMainModule = isMainModule
             compilerModuleFileUrl = self.compilerModulePath.map {_.url()}
-            packagePair = packagePair
-            moduleName = moduleName
+            moduleKey = moduleKey
         )
-        let js = emitter.emitModule(packagePair, module)
-        let jsPath = self.jsOutputPath.slash(packagePair.group).slash(packagePair.name)
-        let jsFile = jsPath.slash(moduleName + ".mjs")
+        let js = emitter.emitModule(module)
+        let packagePath = self.jsOutputPath.slash(moduleKey.packagePair.group).slash(moduleKey.packagePair.name)
+        let jsPath = moduleKey.folders.foldLeft(packagePath) {p, f => p.slash(f)}
+        let jsFile = jsPath.slash(moduleKey.name + ".mjs")
         jsPath.createDirectory(createParentDirectories = True)
         jsFile.writeText(js)
         if(isMainModule) {
             let runJs = emitter.emitRun(
-                moduleName
+                moduleKey.name
                 module.functions
-                packagePair
-                packagePair.group == "ff" && packagePair.name == "compiler"
+                moduleKey.packagePair
+                moduleKey.packagePair.group == "ff" && moduleKey.packagePair.name == "compiler"
             )
-            let jsRunFile = jsPath.slash(moduleName + ".run.mjs")
+            let jsRunFile = jsPath.slash(moduleKey.name + ".run.mjs")
             jsRunFile.writeText(runJs.map {_ + "\n"}.join())
         }
     }

package/compiler/Dependencies.ff

@@ -25,7 +25,8 @@ extend self: Dependencies {
         packagePair: PackagePair
         path: Path
     ): Option[PackageInfo] {
-        let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
+        //let packageDirectory = if(path.extension() == ".ff") {path.parent().grab()} else {path}
+        let packageDirectory = findScriptPackageLocation(path)
         let sharedPackageFile = packageDirectory.slash(".firefly").slash("package.ff")
         let packageFile = if(sharedPackageFile.exists()) {
             sharedPackageFile
@@ -43,7 +44,8 @@ extend self: Dependencies {
         code: String
     ): PackageInfo {
         let tokens = Tokenizer.tokenize(fileName, code, None, True)
-        let parser = Parser.new(packagePair, fileName, tokens, False, LspHook.disabled())
+        let moduleKey = ModuleKey(packagePair, [], "<package>")
+        let parser = Parser.new(moduleKey, tokens, False, LspHook.disabled())
         let info = parser.parsePackageInfo()
         self.addCoreDependencyIfMissing(info)
     }
@@ -144,7 +146,11 @@ process(fetch: HttpClient, dependencyLock: DependencyLock, path: Path): Resolved
     let workspace = Workspace.loadWorkspace(path)
     let self = Dependencies(workspace, [].toMap(), [].toMap(), [].toSet())
     let packageInfo = self.loadPackageInfo(PackagePair("script", "script"), path).else {
-        panic("Not a main file: " + path.absolute())
+        if(!path.exists()) {
+            throw(CompileError(Location(path.absolute(), 1, 1), "File not found"))
+        } else {
+            throw(CompileError(Location(path.absolute(), 1, 1), "Could not load package info"))
+        }
     }
     let newDependencies = self.processPackageInfo(packageInfo)
     self.processDependencies(path, fetch, dependencyLock, newDependencies)

package/compiler/Deriver.ff

@@ -14,7 +14,7 @@ extend self: Deriver {
 
     deriveModule(module: Module): Module {
 
-        let modulePrefix = module.packagePair.groupName() + "/" + module.file.dropLast(3)
+        let modulePrefix = module.moduleKey.qualifiedName()
 
         module.Module(
             instances = [
@@ -620,7 +620,7 @@ extend self: Deriver {
         }.toSet()
 
         module.types.filter {t =>
-            (module.packagePair.groupName() != "ff:core" || coreWhitelist.contains(modulePrefix + "." + t.name)) &&
+            (!module.moduleKey.packagePair.isCore() || coreWhitelist.contains(modulePrefix + "." + t.name)) &&
             !t.generics.first().any {_ == "Q$"} &&
             (allowGenerics || t.generics.isEmpty()) &&
             t.data && !t.newtype &&

package/compiler/Dictionaries.ff

@@ -23,17 +23,17 @@ extend self: Dictionaries {
             | _ => None
         }.toMap()
 
-        let lets = module.lets.map { self.processLetDefinition(functionSignatures, _) }
-        let functions = module.functions.map { self.processFunctionDefinition(functionSignatures, _) }
-        let extends = module.extends.map { self.processExtendDefinition(functionSignatures, _) }
-        //let traits = module.traits.map { self.processTraitDefinition(functionSignatures, _) }
-        let instances = module.instances.map { self.processInstanceDefinition(functionSignatures, _) }
+        let lets = module.lets.map {self.processLetDefinition(functionSignatures, _)}
+        let functions = module.functions.map {self.processFunctionDefinition(functionSignatures, _)}
+        let extends = module.extends.map {self.processExtendDefinition(functionSignatures, _)}
+        //let traits = module.traits.map {self.processTraitDefinition(functionSignatures, _)}
+        let instances = module.instances.map {self.processInstanceDefinition(functionSignatures, _)}
         module.Module(
             //traits = traits,
-            instances = instances,
-            extends = extends,
-            lets = lets,
-            functions = functions,
+            instances = instances
+            extends = extends
+            lets = lets
+            functions = functions
         )
     }
 
@@ -177,7 +177,7 @@ extend self: Dictionaries {
                 let dictionaries = instance.constraints.map {c =>
                     self.makeDictionary(at, instance.generics, firstType.generics, c)
                 }
-                Dictionary(instance.packagePair, instance.moduleName, constraint.name, firstType.name, dictionaries)
+                Dictionary(instance.moduleKey, constraint.name, firstType.name, dictionaries)
             | TVariable t => fail(t.at, " is still a unification variable")
         }
     }
@@ -195,8 +195,7 @@ constraintsToInstances(constraints: List[Constraint]): Map[InstanceKey, Instance
             InstanceValue(
                 generics = []
                 constraints = []
-                packagePair = PackagePair("", "")
-                moduleName = ""
+                moduleKey = ModuleKey(PackagePair("", ""), [], "")
                 traitName = c.name
                 typeArguments = c.generics
             )

package/compiler/Environment.ff

@@ -25,19 +25,19 @@ data Instantiated(
 new(module: Module, otherModules: List[Module], alreadyFlat: Bool): Environment {
     let processed = processModule(module, True, alreadyFlat)
     let otherProcessed = otherModules.map {processModule(_, False, False)}
+    let modulePath = module.moduleKey.importName() + ".ff" // TODO
     Environment(
         modulePrefix = fullName(module, "")
         symbols = processed.symbols.addAll(otherProcessed.map {_.symbols}.foldLeft(Map.new()) {_.addAll(_)})
         traits = processed.traits.addAll(otherProcessed.map {_.traits}.foldLeft(Map.new()) {_.addAll(_)})
         imports = module.imports.map {i => Pair(i.alias, i)}.toMap()
-        effect = TConstructor(Location(module.file, 0, 0), "ff:core/Nothing.Nothing", [])
+        effect = TConstructor(Location(modulePath, 0, 0), "ff:core/Nothing.Nothing", [])
         selfVariable = None
     )
 }
 
 fullName(module: Module, name: String): String {
-    module.packagePair.groupName() + "/" +
-    module.file.dropLast(3) + "." + name
+    module.moduleKey.qualifiedSymbol(name)
 }
 
 fail[T](at: Location, message: String): T {
@@ -154,8 +154,8 @@ processModule(module: Module, isCurrentModule: Bool, alreadyFlat: Bool): Environ
         module.traits.map {d =>
             Pair(fullName(module, d.name), d)
         }
-
-    let effect = TConstructor(Location(module.file, 0, 0), "ff:core/Nothing.Nothing", [])
+    let modulePath = module.moduleKey.importName() + ".ff" // TODO
+    let effect = TConstructor(Location(modulePath, 0, 0), "ff:core/Nothing.Nothing", [])
     Environment(
         modulePrefix = ""
         symbols = [...functions, ...lets, ...fields, ...extends, ...variants, ...traitMethods].toMap()

package/compiler/Inference.ff

@@ -1225,8 +1225,7 @@ constraintsToInstances(constraints: List[Constraint]): Map[InstanceKey, Instance
             InstanceValue(
                 generics = []
                 constraints = []
-                packagePair = PackagePair("", "")
-                moduleName = ""
+                moduleKey = ModuleKey(PackagePair("", ""), [], "")
                 traitName = c.name
                 typeArguments = c.generics
             )

package/compiler/JsEmitter.ff

@@ -8,8 +8,7 @@ class JsEmitter(
     emitTarget: EmitTarget
     isMainModule: Bool
     compilerModuleFileUrl: Option[String]
-    packagePair: PackagePair
-    moduleName: String
+    moduleKey: ModuleKey
     mutable emittingAsync: Bool
     mutable tailCallUsed: Bool
 )
@@ -26,20 +25,17 @@ new(
     emitTarget: EmitTarget
     isMainModule: Bool
     compilerModuleFileUrl: Option[String]
-    packagePair: PackagePair
-    moduleName: String
+    moduleKey: ModuleKey
 ): JsEmitter {
     JsEmitter(
         otherModules = otherModules.map {m =>
-            let moduleName = m.packagePair.groupName() + "/" + m.file.dropLast(3)
-            Pair(moduleName, m)
+            Pair(m.moduleKey.qualifiedName(), m)
         }.toMap()
         jsImporter = JsImporter.new()
         emitTarget = emitTarget
         isMainModule = isMainModule
         compilerModuleFileUrl = compilerModuleFileUrl
-        packagePair = packagePair
-        moduleName = moduleName
+        moduleKey = moduleKey
         emittingAsync = False
         tailCallUsed = False
     )
@@ -51,13 +47,11 @@ fail[T](at: Location, message: String): T {
 
 extend self: JsEmitter {
 
-    emitModule(packagePair: PackagePair, module: Module): String {
-        let selfImport =
-            "import * as " + packagePair.groupName("_") + "_" + module.file.dropLast(3) + " " +
-            "from \"../../" + packagePair.groupName("/") + "/" + module.file.dropLast(3) + ".mjs\""
+    emitModule(module: Module): String {
+        let selfImport = self.emitImport(self.moduleKey)
         let imports = [
             self.compilerModuleFileUrl.map {"import * as $firefly_compiler from '" + _ + "'"}.toList()
-            module.imports.sortBy {i => Pair(i.package, i.file) }.map {self.emitImportDefinition(_)}
+            module.imports.sortBy {_.moduleKey}.map {self.emitImport(_.moduleKey)}
         ].flatten()
         let parts = [
             if(imports.any {_ == selfImport}) {imports} else {[selfImport, ...imports]}
@@ -68,15 +62,24 @@ extend self: JsEmitter {
             module.extends.map {self.emitExtendsDefinition(_)}
             module.instances.map {self.emitInstanceDefinition(_)}
         ]
-        let ignoreJsImports = if(
-            self.emitTarget == EmitExecutable &&
-            packagePair.group == "ff" &&
-            packagePair.name == "core"
-        ) {["esbuild"]} else {[]}
+        let ignoreJsImports = if(self.emitTarget == EmitExecutable && self.moduleKey.packagePair.isCore()) {
+            ["esbuild"]
+        } else {
+            []
+        }
         let jsImports = self.jsImporter.generateImports(ignoreJsImports.toSet())
         [jsImports, ...parts].map {_.join("\n\n")}.join("\n\n") + "\n"
     }
 
+    emitImport(moduleKey: ModuleKey): String {
+        let dots = "../".repeat(self.moduleKey.folders.size() + 2)
+        let jsImportName = moduleKey.packagePair.groupName("_") + "_" + 
+            moduleKey.folders.map {_ + "_"}.join() + moduleKey.name
+        let jsImportFrom = dots + moduleKey.packagePair.groupName("/") + "/" + 
+            moduleKey.folders.map {_ + "/"}.join() + moduleKey.name + ".mjs"
+        "import * as " + jsImportName + " from \"" + jsImportFrom + "\""
+    }
+    
     withEmittingAsync[T](body: () => T): T {
         try {
             self.emittingAsync = True
@@ -153,11 +156,6 @@ extend self: JsEmitter {
         ].join("\n")]}.else {[]}
     }
 
-    emitImportDefinition(definition: DImport): String {
-        "import * as " + definition.package.group + "_" + definition.package.name + "_" + definition.file + " " +
-        "from \"../../" + definition.package.group + "/" + definition.package.name + "/" + definition.file + ".mjs\""
-    }
-
     emitLetDefinition(definition: DLet, mutable: Bool, async: Bool): String {
         let mutability = if(mutable) {"let"} else {"const"}
         let valueCode = self.emitTerm(definition.value, async)
@@ -434,8 +432,10 @@ extend self: JsEmitter {
     }
 
     emitDictionary(d: Dictionary): String {
-        let m = if(d.moduleName != "") {
-            d.packagePair.groupName("_") + "_" + d.moduleName.replace("/", "_") + "."
+        let m = if(d.moduleKey.name != "") {
+            d.moduleKey.packagePair.groupName("_") + "_" + 
+            d.moduleKey.folders.map {_ + "_"}.join() + 
+            d.moduleKey.name + "."
         } else {""}
         let c = m + makeDictionaryName(d.traitName, d.typeName)
         if(d.dictionaries.isEmpty()) {
@@ -601,27 +601,27 @@ extend self: JsEmitter {
                 Some(
                     self.emitTerm(e, async) + ".length"
                 )
-            | "ff:core/Equal.equals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+            | "ff:core/Equal.equals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, typeName, [])]} {
                 primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
             } =>
                 Some("(" + self.emitTerm(left, async) + " === " + self.emitTerm(right, async) + ")")
-            | "ff:core/Equal.notEquals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+            | "ff:core/Equal.notEquals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, typeName, [])]} {
                 primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
             } =>
                 Some("(" + self.emitTerm(left, async) + " !== " + self.emitTerm(right, async) + ")")
-            | "ff:core/Ordering.before" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+            | "ff:core/Ordering.before" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, typeName, [])]} {
                 primitiveTypes.contains(typeName)
             } =>
                 Some("(" + self.emitTerm(left, async) + " < " + self.emitTerm(right, async) + ")")
-            | "ff:core/Ordering.notBefore" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+            | "ff:core/Ordering.notBefore" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, typeName, [])]} {
                 primitiveTypes.contains(typeName)
             } =>
                 Some("(" + self.emitTerm(left, async) + " >= " + self.emitTerm(right, async) + ")")
-            | "ff:core/Ordering.after" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+            | "ff:core/Ordering.after" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, typeName, [])]} {
                 primitiveTypes.contains(typeName)
             } =>
                 Some("(" + self.emitTerm(left, async) + " > " + self.emitTerm(right, async) + ")")
-            | "ff:core/Ordering.notAfter" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
+            | "ff:core/Ordering.notAfter" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, typeName, [])]} {
                 primitiveTypes.contains(typeName)
             } =>
                 Some("(" + self.emitTerm(left, async) + " <= " + self.emitTerm(right, async) + ")")
@@ -1310,8 +1310,9 @@ extend self: JsEmitter {
     emitArgument(callAt: Location, argument: Argument, async: Bool): String {
         argument.value.{
             | ECall(_, StaticCall("ff:core/SourceLocation.callSite", _, _), _, _, _, _) => 
-                "\"" + self.moduleName + ":" + callAt.line + ":" + callAt.column + 
-                "," + self.packagePair.group + "," + self.packagePair.name + "\""
+                "\"" + self.moduleKey.folders.map {_ + "/"}.join() + self.moduleKey.name + 
+                ":" + callAt.line + ":" + callAt.column + 
+                "," + self.moduleKey.packagePair.group + "," + self.moduleKey.packagePair.name + "\""
             | value =>
                 self.emitTerm(value, async)
         }