firefly-compiler 0.4.4 → 0.4.6

package/.hintrc

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "development"
+  ]
+}

package/README.md

@@ -1,96 +1,77 @@
 # Firefly programming language
 
-[Get the VSCode extension](https://marketplace.visualstudio.com/items?itemName=firefly-team.firefly-lang)
+A straightforward language for full-stack development. 
 
-## About the compiler
-This is a bootstrap transpiler for converting Firefly code to JavaScript code.
+* Hybrid imperative+functional style with uncomplicated types.
+* Code sharing between the browser and the server.
+* Comprehensive IDE support (MacOS/Windows/Linux).
+* Cross-compilation of executables (MacOS/Windows/Linux).
+* Asynchronous functions without the async/await hassle.
+* Super simple package management with repeatable builds.
 
-Status: Firefly has been bootstrapped and now transpiles itself into JavaScript.
+*This is a preview. Please take it for a ride and tell us what you think!*
 
-You can create a whole webapp (frontend+backend) in a single file and it can be build as an executable for linux, windows and osx.
+## Writing your first webapp
 
-[See an example webapp](https://github.com/Ahnfelt/firefly-boot/blob/master/experimental/random/rhymeapp/Main.ff)
+Install the [VSCode extension](https://marketplace.visualstudio.com/items?itemName=firefly-team.firefly-lang).
 
-**Async/await inference:** https://www.ahnfelt.net/async-await-inference-in-firefly/
+Create a `WebApp.ff` file.
 
+Type `webapp` and autocomplete to get a minimalistic client and server (you may need to give the extension a few seconds to initialize first).
 
-## Running a main file
+Go to the *Run and debug* side bar and choose *create a launch.json file*.
 
-```
-firefly.sh MyApp.ff
-```
-
-*You must stand in the project directory when running this command.*
-
-This will run `main` or `nodeMain` in MyApp.ff.
-
-If there is a `buildMain(system: BuildSystem)` method, it will be run before `main`,
-and if it calls `system.setAssets(assets)`, those assets will be available to the main file via `system.assets()`.
+Press F5 or click *Run*. View the running webapp at http://localhost:8080/
 
-You can also have a `browserMain(system: BrowserSystem)` in the file, which can be compiled to a browser JS-file and included as an asset.
-
-Missing dependencies are fetched from the central or configured package repository before building and running.
+In the `WebApp.ff` file you'll see a `nodeMain`, which runs on the server, and a `browserMain`, which runs on the client. There's also a `buildMain` which is the build step that compiles the client side code to JavaScript so that it can be served to the browser.
 
 ## Building an executable
 
-```
-firefly.sh build MyApp.ff
-```
+Install the `firefly` compiler:
 
-*You must stand in the project directory when running this command.*
+```npm install -g firefly-compiler```
 
-This will generate a stand-alone executable file `MyApp` with the necessary assets and dependencies, compatible with most linux distributions, windows and osx.
+Build executables for Linux, MacOS and Windows:
 
-If there is a `buildMain(system: BuildSystem)` method, it will be run before producing the executables,
-and if it calls `system.setAssets(assets)`, those assets will be included in the executables and thus be available to the main file via `system.assets()`.
+```firefly build WebApp.ff```
 
-## Building for the browser
+You can find the executables in `.firefly/`
 
-```
-firefly.sh browser MyApp.ff
-```
+The command line interface can also run `WebApp.ff` directly by typing: 
 
-*You must stand in the project directory when running this command.*
+```firefly WebApp.ff```
 
-This generates a single, minified `MyApp.min.js`, compatible with all modern browsers (ES6+).
+## Connecting to PostgreSQL
 
-## Bootstrapping the compiler
+To connect to a PostgreSQL database, add this dependency to the top of the file:
 
-```
-firefly.sh bootstrap
-```
+```dependency ff:postgresql:0.0.0```
 
-*You must stand in the project directory when running this command.*
+And import the `Pg` module from it:
 
-If you botch the compiler, just roll back the output directory and try again.
+```import Pg from ff:postgresql```
 
-## Dependencies and imports
+Create a connection pool with the appropriate connection parameters:
 
-You may list your dependencies either in the top of the main file or in `.firefly/package.ff`.
+```let pool = Pg.makePool(...)```
 
-In order to establish a package directory, and thus allow importing other files from the current package, you must place a `.firefly/package.ff` file. 
+And run your first transaction, e.g.:
 
-Example (all lines optional):
 ```
-package john:stuff:0.1.7
-dependency anne:goodies:2.1.0
-dependency chris:images:0.7.0
+pool.transaction {connection =>
+    let emails = connection.statement("""
+        select email from users
+    """).map {row =>
+        row.getString("email").grab()
+    }
+    Log.debug(emails)
+}
 ```
 
-You don't have to manually install dependencies - they will be automatically downloaded when necessary.
-
-## Workspaces
+## What's next
 
-You may place a `.firefly-workspace` file somewhere in a parent directory.
+For now, you're on your own! Lots of things you'll be missing. We're working on it.
 
-The workspace file configures where source code is fetched from. 
+To follow the development or get help, join `#firefly` on https://discord.gg/FHv8vXJNVf - we're a friendly bunch, and your feedback is appreciated!
 
-It can be a local directory or a remote repository.
-
-Example:
-
-```
-foo:stuff projects/foo/stuff
-bar:* projects/foo
-* https://example.com/repository
-```
+This repository contains the source code of the compiler and language server. It's all written in Firefly! Apart from `extension.js`, the JavaScript files you see in this repository are generated from Firefly code.

package/compiler/Compiler.ff

@@ -66,6 +66,7 @@ coreImports: List[DImport] =
         "AssetSystem"
         "Atomic"
         "Bool"
+        "Box"
         "BrowserSystem"
         "Buffer"
         "BuildSystem"
@@ -96,6 +97,7 @@ coreImports: List[DImport] =
         "Serializable"
         "Set"
         "Show"
+        "SourceLocation"
         "Stack"
         "Stream"
         "String"
@@ -181,7 +183,7 @@ extend self: Compiler {
 
         let module = self.parse(packagePair, moduleName, None)
         let otherModules = self.imports(module)
-        let resolver = Resolver.make(self.lspHook)
+        let resolver = Resolver.make(packagePair, moduleName, self.lspHook)
         let result = resolver.resolveModule(module, otherModules)
 
         self.resolvedModules = self.resolvedModules.add(packageName + ":" + moduleName, result)
@@ -230,7 +232,9 @@ extend self: Compiler {
             self.infer(i.packagePair, newModuleName)
         }
 
-        let js = JsEmitter.make([module, ...otherModules], self.emitTarget, isMainModule, self.compilerModulePath)
+        let allModules = [module, ...otherModules]
+        let js = 
+            JsEmitter.make(allModules, self.emitTarget, isMainModule, self.compilerModulePath, packagePair, moduleName)
             .emitModule(packagePair, module)
         let jsPath = self.jsOutputPath.slash(packagePair.group).slash(packagePair.name)
         let jsFile = jsPath.slash(moduleName + ".mjs")

package/compiler/Deriver.ff

@@ -33,6 +33,15 @@ extend self: Deriver {
         let coreWhitelist = [
             "ff:core/Serializable.DeserializationChecksumException"
             "ff:core/Core.GrabException"
+            "ff:core/Unit.Unit"
+            "ff:core/Pair.Pair"
+            "ff:core/Option.Option"
+            "ff:core/Int.Int"
+            "ff:core/Float.Float"
+            "ff:core/String.String"
+            "ff:core/Char.Char"
+            "ff:core/Bool.Bool"
+            "ff:core/List.List"
         ].toSet() // Maybe whitelist all?
         let missingInstance =
             self.findTypesThatNeedInstances("ff:core/Any.HasAnyTag", modulePrefix, coreWhitelist, True, module)
@@ -310,6 +319,7 @@ extend self: Deriver {
             "ff:core/Option.Option"
             "ff:core/List.List"
             "ff:core/Pair.Pair"
+            "ff:core/Unit.Unit"
         ].toSet()
         let missingInstance =
             self.findTypesThatNeedInstances("ff:core/Equal.Equal", modulePrefix, coreWhitelist, True, module)

package/compiler/Environment.ff

@@ -91,11 +91,12 @@ processModule(module: Module, isCurrentModule: Bool, alreadyFlat: Bool): Environ
                         let effect = method.signature.generics.filter {_ == "Q$"}
                         let normalGenerics = method.signature.generics.filter {_ != "Q$"}
                         let outerGenerics = if(alreadyFlat) {[]} else {d.generics}
+                        let outerConstraints = if(alreadyFlat) {[]} else {d.constraints}
                         Pair(
                             prefix + method.signature.name
                             Scheme(False, False, False, False, method.signature.Signature(
                                 generics = [...effect, ...outerGenerics, ...normalGenerics]
-                                constraints = [...d.constraints, ...method.signature.constraints]
+                                constraints = [...outerConstraints, ...method.signature.constraints]
                                 parameters = [selfParameter, ...method.signature.parameters]
                             ))
                         )

package/compiler/JsEmitter.ff

@@ -8,6 +8,8 @@ capability JsEmitter(
     emitTarget: EmitTarget
     isMainModule: Bool
     compilerModulePath: Option[Path]
+    packagePair: PackagePair
+    moduleName: String
     mutable emittingAsync: Bool
     mutable tailCallUsed: Bool
 )
@@ -24,6 +26,8 @@ make(
     emitTarget: EmitTarget
     isMainModule: Bool
     compilerModulePath: Option[Path]
+    packagePair: PackagePair
+    moduleName: String
 ): JsEmitter {
     JsEmitter(
         otherModules = otherModules.map {m =>
@@ -34,6 +38,8 @@ make(
         emitTarget = emitTarget
         isMainModule = isMainModule
         compilerModulePath = compilerModulePath
+        packagePair = packagePair
+        moduleName = moduleName
         emittingAsync = False
         tailCallUsed = False
     )
@@ -298,7 +304,7 @@ extend self: JsEmitter {
         | EVariant(at, "ff:core/Unit.Unit", _, _) =>
             "(void 0)"
         | EVariant(at, name, _, arguments) =>
-            let argumentsString = arguments.toList().flatten().map {self.emitArgument(_, async)}.join(", ")
+            let argumentsString = arguments.toList().flatten().map {self.emitArgument(at, _, async)}.join(", ")
             let newtype = self.processVariant(name)
             if(newtype) { argumentsString } else:
             escapeResolved(name) + "(" + argumentsString + ")"
@@ -347,9 +353,9 @@ extend self: JsEmitter {
             let call = "(" + self.emitTerm(function, async) + ")(" + self.emitTerm(value, async) + c + ")"
             if(await) {"(await " + call + ")"} else {call}
         | ECall(at, StaticCall(operator, _, _), _, [], [value], _) {!operator.grabFirst().isAsciiLetter()} =>
-            "(" + operator + self.emitArgument(value, async) + ")"
+            "(" + operator + self.emitArgument(at, value, async) + ")"
         | ECall(at, StaticCall(operator, _, _), _, [], [left, right], _) {!operator.grabFirst().isAsciiLetter()} =>
-            "(" + self.emitArgument(left, async) + " " + operator + " " + self.emitArgument(right, async) + ")"
+            "(" + self.emitArgument(at, left, async) + " " + operator + " " + self.emitArgument(at, right, async) + ")"
         | ECall(at, StaticCall("ff:unsafejs/UnsafeJs.import", _, _), _, _, [Argument(_, _, EString(_, url))], _) =>
             self.jsImporter.add(url.replace("\"", ""))
         | ECall(at, StaticCall("ff:unsafejs/UnsafeJs.await", _, _), _, _, [Argument(_, _, body)], _) =>
@@ -362,27 +368,27 @@ extend self: JsEmitter {
         | ECall(at, StaticCall("ff:core/Equal.equals", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
             primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
         } =>
-            "(" + self.emitArgument(left, async) + " === " + self.emitArgument(right, async) + ")"
+            "(" + self.emitArgument(at, left, async) + " === " + self.emitArgument(at, right, async) + ")"
         | ECall(at, StaticCall("ff:core/Equal.notEquals", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
             primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
         } =>
-            "(" + self.emitArgument(left, async) + " !== " + self.emitArgument(right, async) + ")"
+            "(" + self.emitArgument(at, left, async) + " !== " + self.emitArgument(at, right, async) + ")"
         | ECall(at, StaticCall("ff:core/Ordering.before", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
             primitiveTypes.contains(typeName)
         } =>
-            "(" + self.emitArgument(left, async) + " < " + self.emitArgument(right, async) + ")"
+            "(" + self.emitArgument(at, left, async) + " < " + self.emitArgument(at, right, async) + ")"
         | ECall(at, StaticCall("ff:core/Ordering.notBefore", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
             primitiveTypes.contains(typeName)
         } =>
-            "(" + self.emitArgument(left, async) + " >= " + self.emitArgument(right, async) + ")"
+            "(" + self.emitArgument(at, left, async) + " >= " + self.emitArgument(at, right, async) + ")"
         | ECall(at, StaticCall("ff:core/Ordering.after", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
             primitiveTypes.contains(typeName)
         } =>
-            "(" + self.emitArgument(left, async) + " > " + self.emitArgument(right, async) + ")"
+            "(" + self.emitArgument(at, left, async) + " > " + self.emitArgument(at, right, async) + ")"
         | ECall(at, StaticCall("ff:core/Ordering.notAfter", _, _), _, _, [left, right], [Dictionary(_, _, _, typeName, [])]) {
             primitiveTypes.contains(typeName)
         } =>
-            "(" + self.emitArgument(left, async) + " <= " + self.emitArgument(right, async) + ")"
+            "(" + self.emitArgument(at, left, async) + " <= " + self.emitArgument(at, right, async) + ")"
         | ECall(_, StaticCall("ff:core/Array.fillBy", _, _), effect, _, [size, Argument(_, _, ELambda(at,
             Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)@c])@l
         ))], _) {
@@ -390,7 +396,7 @@ extend self: JsEmitter {
         } =>
             let n = name.map {escapeResolved(_)}.else {"i"}
             "((() => {\n" +
-            "const size = " + self.emitArgument(size, async) + ";\n" +
+            "const size = " + self.emitArgument(at, size, async) + ";\n" +
             "const result = [];\n" +
             "for(let " + n + " = 0; " + n + " < size; " + n + "++) {\n" +
             "result.push(" + self.emitTerm(body, async) + ");\n" +
@@ -404,7 +410,7 @@ extend self: JsEmitter {
             let d = dictionaryStrings.grabFirst()
             let asyncSuffix = if(await) {"$"} else {""}
             let n = escapeKeyword(name.reverse().takeWhile { _ != '.' }.reverse()) + asyncSuffix
-            let emittedArguments = arguments.map{self.emitArgument(_, async)}
+            let emittedArguments = arguments.map {self.emitArgument(at, _, async)}
             let controller = if(await) {["$task"]} else {[]}
             let call = d + "." + n + "(" + [...emittedArguments, ...ds, ...controller].join(", ") + ")"
             if(await) {"(await " + call + ")"} else {call}
@@ -414,7 +420,7 @@ extend self: JsEmitter {
                     let await = async && effectTypeIsAsync(effect)
                     let ds = dictionaries.map {self.emitDictionary(_)}
                     let functionCode = escapeResolved(name) + if(await) {"$"} else {""}
-                    let emittedArguments = arguments.map {self.emitArgument(_, async)}
+                    let emittedArguments = arguments.map {self.emitArgument(at, _, async)}
                     let controller = if(await) {["$task"]} else {[]}
                     let call = functionCode + "(" + [...emittedArguments, ...ds, ...controller].join(", ") + ")"
                     if(await) {"(await " + call + ")"} else {call}
@@ -433,7 +439,7 @@ extend self: JsEmitter {
             let await = async && effectTypeIsAsync(effect)
             if(!dictionaries.isEmpty()) {fail(at, "Internal error: Dictionaries in lambda call")}
             let functionCode = self.emitTerm(function, async)
-            let emittedArguments = arguments.map {self.emitArgument(_, async)}
+            let emittedArguments = arguments.map {self.emitArgument(at, _, async)}
             let controller = if(await) {["$task"]} else {[]}
             let call = functionCode + "(" + [...emittedArguments, ...controller].join(", ") + ")"
             if(await) {"(await " + call + ")"} else {call}
@@ -500,7 +506,7 @@ extend self: JsEmitter {
             | ECall(at, StaticCall("ff:core/Core.doWhile", _, _), _, _, [Argument(_, _, doWhileBody)], _) {
                 invokeImmediately(doWhileBody) | body
             } =>
-                "while(!" + self.emitTerm(body, async) + ") {}"
+                "while(" + self.emitTerm(body, async) + ") {}"
             | ECall(at, StaticCall("ff:core/Core.if", _, _), _, _, [condition, body], _) =>
                 "if(" + self.emitTerm(condition.value, async) + ") {\n" +
                 if(last) {
@@ -511,7 +517,7 @@ extend self: JsEmitter {
                 }
             | ECall(at, StaticCall("ff:core/Core.throw", _, _), _, _, [argument], [dictionary]) =>
                 let d = self.emitDictionary(dictionary)
-                let a = self.emitArgument(argument, async)
+                let a = self.emitArgument(at, argument, async)
                 "throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(" + a + ", " + d + ")})"
             | ECall(at, StaticCall("ff:core/Core.try", _, _), _, _, _, _) {!last} =>
                 throw(CompileError(at, "Statements can't be a try without a grab"))
@@ -769,8 +775,14 @@ extend self: JsEmitter {
         newtype
     }
 
-    emitArgument(argument: Argument, async: Bool): String {
-        self.emitTerm(argument.value, async)
+    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 + "\""
+            | value =>
+                self.emitTerm(value, async)
+        }
     }
 
 }

package/compiler/Resolver.ff

@@ -20,7 +20,7 @@ class ResolverState(
     mutable nextUnificationVariableIndex: Int
 )
 
-make(lspHook: LspHook): Resolver {
+make(packagePair: PackagePair, moduleName: String, lspHook: LspHook): Resolver {
     Resolver(
         variables = [].toMap()
         variableLocations = [].toMap()

package/core/.firefly/package.ff

@@ -1,2 +1 @@
-package ff:core:0.0.0
-include "node_modules"
+package ff:core:0.0.0

package/core/Box.ff

@@ -0,0 +1,7 @@
+class Box[T](mutable value: T)
+
+extend self[T]: Box[T] {
+    modify(body: T => T): Unit {
+        self.value = body(self.value)
+    }
+}

package/core/BuildSystem.ff

@@ -48,14 +48,15 @@ extend self: BrowserCode {
 
     bundle(minify: Bool = True, sourceMap: Bool = False): BrowserBundle {
         let prefix = ".firefly/output/browser"
-        let mainJsBaseFile = self.mainFile.absolute().removeLast(".ff").grab() + ".mjs"
+        let mainJsBaseFile = self.mainFile.base().removeLast(".ff").grab() + ".mjs"
         let mainJsFile = prefix + "/" + self.packageGroup + "/" + self.packageName + "/" + mainJsBaseFile
+        let mainDirectory = self.mainFile.parent().grab()
         let file = prefix + "/Main.bundle.js"
         internalCallEsBuild(self, mainJsFile = mainJsFile, outputPath = file, minify = minify, sourceMap = sourceMap)
         let assets = AssetSystem([
-            Pair(file.dropFirst(prefix.size()), {self.mainFile.path(file).readStream()})
+            Pair(file.dropFirst(prefix.size()), {mainDirectory.path(file).readStream()})
             ...if(sourceMap) {[
-                Pair(file.dropFirst(prefix.size()) + ".map", {self.mainFile.path(file + ".map").readStream()})
+                Pair(file.dropFirst(prefix.size()) + ".map", {mainDirectory.path(file + ".map").readStream()})
             ]} else {[]}
         ].toMap())
         BrowserBundle(assets)
@@ -124,7 +125,7 @@ internalListDirectory(path: Path): List[Pair[String, () => Stream[Buffer]]] {
         }
     }
     go(path).map {file =>
-        Pair("/" + file.relativeTo(path), {file.readStream()})
+        Pair("/" + file.relativeTo(path).replace("\\", "/"), {file.readStream()})
     }.toList()
 }
 

package/core/Core.ff

@@ -55,4 +55,8 @@ throwAny[T](exception: Any): T
 panic[T](message: String): T
     target js sync "throw new Error(message_)"
 
+
+same[T](x: T, y: T): Bool
+    target js sync """return x_ === y_"""
+    
 data GrabException()

package/core/HttpClient.ff

@@ -27,7 +27,7 @@ extend self: HttpClient {
             try {
                 const options = {headers: {}, signal: $task.controller.signal}
                 options.method = method_
-                ff_core_List.List_each(headers_, pair => {options.headers[pair.key_] = pair.value_})
+                ff_core_List.List_each(headers_, pair => {options.headers[pair.first_] = pair.second_})
                 if(body_.value_) options.body = body_.value_
                 if(redirect_.RedirectError) options.redirect = "error"
                 else if(redirect_.RedirectManual) options.redirect = "manual"

package/core/JsValue.ff

@@ -26,6 +26,9 @@ extend self: JsValue {
             return self_
         """
 
+    equals[V: IsJsValue](value: V): Bool
+        target js sync "return self_ === value_"
+
     isString(): Bool
         target js sync "return typeof self_ === 'string'"
 
@@ -52,7 +55,7 @@ extend self: JsValue {
 
     isFunction(): Bool
         target js sync "return typeof self_ === 'function'"
-
+        
     isNull(): Bool
         target js sync "return self_ === null"
 
@@ -80,6 +83,9 @@ extend self: JsValue {
     set[K: IsJsValue, V: IsJsValue](key: K, value: V): Unit
         target js sync "self_[key_] = value_"
 
+    delete[K: IsJsValue](key: K): Unit
+        target js sync "delete self_[key_]"
+
     with[K: IsJsValue, V: IsJsValue](key: K, value: V): JsValue
         target js sync "return {...self_, [key_]: value_}"
 
@@ -219,6 +225,19 @@ extend self: JsValue {
     grabMap(): Map[String, JsValue] {
         self.grabPairs().toMap()
     }
+
+    grabIntMap(): IntMap[JsValue]
+        target js sync """
+            if(!(self_ instanceof Map)) throw new Error('Expected map, got '+ typeof self_);;
+            return self_
+        """
+
+    grabStringMap(): StringMap[JsValue]
+        target js sync """
+            if(!(self_ instanceof Map)) throw new Error('Expected map, got '+ typeof self_);;
+            return self_
+        """
+
     //toArray(): Array[JsValue] // TODO
     //toList(): List[JsValue] // TODO
     // TODO: JS operators
@@ -233,6 +252,8 @@ instance Int: IsJsValue {}
 instance Float: IsJsValue {}
 instance Bool: IsJsValue {}
 instance Array[T: IsJsValue]: IsJsValue {}
+instance IntMap[T: IsJsValue]: IsJsValue {}
+instance StringMap[T: IsJsValue]: IsJsValue {}
 instance Error: IsJsValue {}
 instance Instant: IsJsValue {}
 instance Duration: IsJsValue {}

package/core/Lock.ff

@@ -8,13 +8,13 @@ extend self: Lock {
             return {lock: self_, stack: [], queue: []}
         """
 
-    acquire(): Unit
+    acquire(reentrant: Bool): Unit
         target js async """
             if(self_.level === 0) {
                 self_.owner = $task
                 self_.level += 1
             } else {
-                if(self_.owner !== $task) {
+                if(self_.owner !== $task || !reentrant_) {
                     try {
                         await new Promise((resolve, reject) => {
                             $task.controller.signal.addEventListener('abort', reject)
@@ -56,8 +56,8 @@ extend self: Lock {
             }
         """
     
-    do[T](body: () => T): T {
-        self.acquire()
+    do[T](reentrant: Bool, body: () => T): T {
+        self.acquire(reentrant)
         try {
             body()
         } finally {

package/core/NodeSystem.ff

@@ -8,12 +8,13 @@ extend self: NodeSystem {
     assets(): AssetSystem {
         let assetPkgSnapshotPath = self.path("/snapshot/output/assets")
         if(assetPkgSnapshotPath.isDirectory()) {
+            // Opendir gives ENOENT: no such file or directory, opendir '/snapshot/output/assets'
             function streams(path: Path): Stream[Pair[String, () => Stream[Buffer]]] {
-                path.entries().flatMap {file =>
+                internalListDirectoryWithoutOpendir(self, path).toStream().flatMap {file =>
                     if(file.isDirectory()) {
-                        streams(file.path())
+                        streams(file)
                     } else {
-                        [Pair(file.path().relativeTo(assetPkgSnapshotPath), {file.path().readStream()})].toStream()
+                        [Pair("/" + file.relativeTo(assetPkgSnapshotPath), {file.readStream()})].toStream()
                     }
                 }
             }
@@ -86,3 +87,11 @@ extend self: NodeSystem {
 
 internalAssets(system: NodeSystem): AssetSystem
     target node async "return system_.assets_"
+
+internalListDirectoryWithoutOpendir(system: NodeSystem, path: Path): Array[Path]
+    target node async """
+        import * as fsPromises from 'fs/promises'
+        import * as path from 'path'
+        let files = await fsPromises.readdir(path_)
+        return files.map(file => path.join(path_, file))
+    """

package/core/Path.ff

@@ -93,7 +93,7 @@ extend self: Path {
                     return ff_core_Option.Some(entry)
                 },
                 async () => {
-                    await dir.close()
+                    if(dir !== null) await dir.close()
                 }
             )
         """

package/core/SourceLocation.ff

@@ -0,0 +1,41 @@
+newtype SourceLocation(location: String) // E.g. "directory/Module:line:column,group,package>Type>function"
+
+here(location: SourceLocation = SourceLocation.callSite()): SourceLocation {
+    location
+}
+
+callSite(): SourceLocation {
+    panic("SourceLocation.callSite() can only occur as the default value of an argument")
+}
+
+extend self: SourceLocation {
+
+    group(): String {
+        self.location.dropWhile {_ != ','}.dropFirst().takeWhile {_ != ','}
+    }
+    
+    package(): String {
+        self.location.dropWhile {_ != ','}.dropFirst().dropWhile {_ != ','}.dropFirst().takeWhile {_ != '>'}
+    }
+    
+    directory(): String {
+        self.location.takeWhile {_ != ':'}.reverse().dropWhile {_ != '/'}.dropFirst().reverse()
+    }
+
+    module(): String {
+        self.location.takeWhile {_ != ':'}.reverse().takeWhile {_ != '/'}.reverse()
+    }
+    
+    line(): Int {
+        self.location.dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ':'}.grabInt()
+    }
+
+    column(): Int {
+        self.location.dropWhile {_ != ':'}.dropFirst().dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ','}.grabInt()
+    }
+    
+    breadcrumbs(): Array[String] {
+        self.location.dropWhile {_ != '>'}.dropFirst().split('>')
+    }
+
+}