firefly-compiler 0.4.10 → 0.4.11

package/lsp/LanguageServer.ff

@@ -8,13 +8,13 @@ data BadRequestException(reason: String)
 
 capability Request(
     headers: Map[String, String]
-    object: JsValue
+    object: Json
 )
 
 capability RequestMessage(
     id: Option[MessageId] // None when the request is a Notification Message
     method: String
-    parameters: Map[String, JsValue]
+    parameters: Map[String, Json]
 )
 
 logMessages = False
@@ -31,11 +31,11 @@ main(system: NodeSystem) {
     let handler = Handler(fireflyPath, None, Map.empty(), [].toSet(), Map.empty(), Map.empty())
     try {
         mutable input = system.readStream()
-        let responseChannel: Channel[Pair[JsValue, String]] = system.mainTask().channel()
+        let responseChannel: Channel[Pair[Json, String]] = system.mainTask().channel()
         system.mainTask().spawn {_ =>
             while {True} {
                 let body = responseChannel.read()
-                let json = body.first.toJson(Some("    ")).toBuffer()
+                let json = body.first.write(Some("    ")).toBuffer()
                 logDirectory.each {logMessage(_, "response", body.first, body.second)}
                 system.writeText("Content-Length: " + json.size() + "\r\n\r\n")
                 system.writeBuffer(json)
@@ -65,7 +65,7 @@ main(system: NodeSystem) {
                             Error(-32603, "Internal error")
                         }
                         message.id.each {id => 
-                            let body = makeResponseMessage(system.js(), id, problem)
+                            let body = makeResponseMessage(id, problem)
                             responseChannel.write(Pair(body, message.method))
                         }
                     } grab()
@@ -106,7 +106,7 @@ parseRequest(system: NodeSystem, input: Stream[Buffer]): Pair[Request, Stream[Bu
     let contentLength = headers
         .get("content-length").else {throw(BadRequestException("'content-length' header is missing"))}
         .getInt().else {throw(BadRequestException("Value for 'content-length' is not an integer"))}
-    let bodyPair = parseRequestBody(system.js(), contentLength, headersPair.second)
+    let bodyPair = parseRequestBody(contentLength, headersPair.second)
     bodyPair.mapFirst {body => Request(headers, body)}
 }
 
@@ -153,31 +153,29 @@ parseRequestHeaders(input: Stream[Buffer]): Pair[Map[String, String], Stream[Buf
     Pair(map, [buffer.view(offset, buffer.size())].toStream().addAll(input))
 }
 
-parseRequestBody(js: JsSystem, contentLength: Int, input: Stream[Buffer]): Pair[JsValue, Stream[Buffer]] {
+parseRequestBody(contentLength: Int, input: Stream[Buffer]): Pair[Json, Stream[Buffer]] {
     let bodyPair = try {
         input.readBytes(contentLength) // Should Stream.readBytes return an option?
     } catchAny {error =>
         throw(BadRequestException("End of input while parsing request body"))
     } grab()
     let body = Buffer.fromBufferArray(bodyPair.first).toString()
-    let json = try {
-        js.parseJson(body)
-    } catchAny {error =>
+    let json = Json.read(body).else {
         throw(BadRequestException("Invalid JSON in request body: " + body))
-    } grab()
+    }
     Pair(json, bodyPair.second)
 }
 
-parseRequestMessage(object: JsValue): RequestMessage {
-    let id = object.getOwn("id").map {parseMessageId(_)}
+parseRequestMessage(object: Json): RequestMessage {
+    let id = object.getField("id").map {parseMessageId(_)}
 
-    let method = object.getOwn("method").{
+    let method = object.getField("method").{
         | None => throw(BadRequestException("Bad JSON-RPC, missing method"))
         | Some(m) {!m.isString()} => throw(BadRequestException("Bad JSON-RPC method, string expected"))
         | Some(m) => m.grabString()
     }
 
-    let parameters = object.getOwn("params").{
+    let parameters = object.getField("params").{
         | None => [].toMap()
         | Some(o) {!o.isObject()} => throw(BadRequestException("Bad JSON-RPC params, object expected"))
         | Some(o) => o.grabMap()
@@ -186,7 +184,7 @@ parseRequestMessage(object: JsValue): RequestMessage {
     RequestMessage(id, method, parameters)
 }
 
-parseMessageId(id: JsValue): MessageId {
+parseMessageId(id: Json): MessageId {
     if(id.isInt()) {
         MessageIdInt(id.grabInt())
     } elseIf {id.isString()} {
@@ -196,7 +194,7 @@ parseMessageId(id: JsValue): MessageId {
     }
 }
 
-handleRequestMessage(system: NodeSystem, handler: Handler, message: RequestMessage): Option[JsValue] {
+handleRequestMessage(system: NodeSystem, handler: Handler, message: RequestMessage): Option[Json] {
     try {
         message.id.{
             | None {message.method == "$/cancelRequest"} => // TODO: Needs to read ahead to cancel anything
@@ -209,10 +207,10 @@ handleRequestMessage(system: NodeSystem, handler: Handler, message: RequestMessa
                 None
             | Some(id) {handler.cancelledRequests.contains(id)} =>
                 handler.cancelledRequests = handler.cancelledRequests.remove(id)
-                Some(makeResponseMessage(system.js(), id, Error(-32800, "Request cancelled")))
+                Some(makeResponseMessage(id, Error(-32800, "Request cancelled")))
             | Some(id) =>
                 let result = handler.handleRequest(system, message.method, message.parameters)
-                Some(makeResponseMessage(system.js(), id, result))
+                Some(makeResponseMessage(id, result))
         }
     } catchAny {error =>
         //system.files().writeText("lsp-failure.txt", error.name() + ": " + error.message())
@@ -220,35 +218,34 @@ handleRequestMessage(system: NodeSystem, handler: Handler, message: RequestMessa
     } grab()
 }
 
-makeResponseMessage(js: JsSystem, id: MessageId, result: ResultOrError): JsValue {
-    let o = js.object()
-    o.set("jsonrpc", "2.0")
+makeResponseMessage(id: MessageId, result: ResultOrError): Json {
+    mutable o = Json.object().with("jsonrpc", "2.0")
     id.{
-        | MessageIdInt(id) => o.set("id", id)
-        | MessageIdString(id) => o.set("id", id)
+        | MessageIdInt(id) => o = o.with("id", id)
+        | MessageIdString(id) => o = o.with("id", id)
     }
     result.{
         | Result(result) =>
-            o.set("result", js.parseJson(result))
+            o = o.with("result", Json.read(result).grab())
         | Error(code, message) =>
-            let e = js.object()
-            e.set("code", code)
-            e.set("message", message)
-            o.set("error", e)
+            let e = Json.object()
+                .with("code", code)
+                .with("message", message)
+            o = o.with("error", e)
     }
     o
 }
 
-logMessage(directory: Path, messageType: String, body: JsValue, method: String) {
+logMessage(directory: Path, messageType: String, body: Json, method: String) {
     let id = if(method == "$/cancelRequest") {
-        Some(body.get("params").get("id").grabInt())
+        Some(body.field("params").field("id").grabInt())
     } else {
-        body.getOwn("id").map {_.grabInt()}
+        body.field("id").getInt()
     }
     let number = directory.entries().toList().size()
     let idName = id.map {_ + ""}.else {"_"}
     let methodName = method.replace("$", "notification").replace("/", "_")
     let fileName = number + "-id-" + idName + "-" + messageType + "-" + methodName + ".json"
     let path = directory.slash(fileName)
-    path.writeText(body.toJson(Some("    ")))
+    path.writeText(body.write(Some("    ")))
 }

package/lsp/SignatureHelpHandler.ff

@@ -5,7 +5,7 @@ import Syntax from ff:compiler
 import Handler
 import CompletionHandler
 
-handleSignatureHelp(system: NodeSystem, lspHook: LspHook): JsValue {
+handleSignatureHelp(system: NodeSystem, lspHook: LspHook): Json {
     let signatureAndUnification = lspHook.results().collectFirst {
         | InferLookupHook h => 
             let isMember = h.symbol.value.qualifiedName.contains("_")
@@ -17,7 +17,6 @@ handleSignatureHelp(system: NodeSystem, lspHook: LspHook): JsValue {
             }
         | _ => None
     }
-    let js = system.js()
     signatureAndUnification.map {| Pair(s, unification) => 
         let shownTypes = [...s.parameters.map {_.valueType}, s.returnType].map {unification.substitute(_)}
         let realGenerics = s.generics.filter {_ != "Q$"}
@@ -28,26 +27,26 @@ handleSignatureHelp(system: NodeSystem, lspHook: LspHook): JsValue {
         }
         let label = 
             s.name + generics + "(" + parameters.join(", ") + "): " + unification.substitute(s.returnType).show(shownTypes)
-        js.object()
-            .with("signatures", js.array([js.object()
+        Json.object()
+            .with("signatures", [Json.object()
                 .with("label", label)
-                .with("parameters", js.array([
+                .with("parameters", [
                     ...parameters.map {p => 
-                        js.object().with("label", p)
+                        Json.object().with("label", p)
                     }
                     // Fake parameter to trick the client into remembering the call position
-                    js.object().with("label", "/* Call " + lspHook.at.show() + " */")
-                ]))
-            ]))
+                    Json.object().with("label", "/* Call " + lspHook.at.show() + " */")
+                ])
+            ])
             .with("activeSignature", 0)
-    }.else {js.null()}
+    }.else {Json.null()}
 }
 
-pickActiveParameter(help: JsValue, argumentIndex: Int, parameterName: Option[String]): JsValue {
+pickActiveParameter(help: Json, argumentIndex: Int, parameterName: Option[String]): Json {
     parameterName.flatMap {name =>
-        let parameters = help.get("signatures").get(0).get("parameters").grabArray().toList()
+        let parameters = help.field("signatures").index(0).field("parameters").grabArray().toList()
         parameters.pairs().collectFirst {| Pair(i, p) => 
-            if(name == p.get("label").grabString().takeWhile {_.isAsciiLetterOrDigit()}) {
+            if(name == p.field("label").grabString().takeWhile {_.isAsciiLetterOrDigit()}) {
                 help.with("activeParameter", i)
             }
         }

package/lsp/SymbolHandler.ff

@@ -50,18 +50,18 @@ readSymbol(hooks: List[ResultHook]): Result[DocumentSymbol] {
         }
 }
 
-handleDocumentSymbol(system: NodeSystem, resultHooks: List[ResultHook]): List[JsValue] {
+handleDocumentSymbol(system: NodeSystem, resultHooks: List[ResultHook]): List[Json] {
     let symbols = readAllSymbols(resultHooks)
-    symbols.map {documentSymbolToLsp(system.js(), _)}
+    symbols.map {documentSymbolToLsp(_)}
 }
 
-handleWorkspaceSymbol(system: NodeSystem, resultHooks: List[ResultHook], query: String): List[JsValue] {
+handleWorkspaceSymbol(system: NodeSystem, resultHooks: List[ResultHook], query: String): List[Json] {
     let documentSymbols = readAllSymbols(resultHooks)
     let workspaceSymbols = documentSymbols.flatMap {documentToWorkspaceSymbols(_, None)}
     let foundSymbols = workspaceSymbols.filter {_.name.startsWith(query)}
     //Log.trace("handleWorkspaceSymbol")
     //workspaceSymbols.each {Log.show(_)}
-    let jsSymbols = foundSymbols.map {workspaceSymbolToLsp(system.js(), system.path("."), _)}
+    let jsSymbols = foundSymbols.map {workspaceSymbolToLsp(system.path("."), _)}
     //workspaceSymbolsJs.each {Log.trace(_.toJson(None))}
     jsSymbols
 }
@@ -90,22 +90,22 @@ showPosition(at: Location): String {
     at.line + ":" + at.column
 }
 
-documentSymbolToLsp(js: JsSystem, symbol: DocumentSymbol): JsValue {
-    js.object()
+documentSymbolToLsp(symbol: DocumentSymbol): Json {
+    Json.object()
         .with("name", symbol.name)
         .with("kind", symbol.kind)
-        .with("range", locationsToLspRange(js, symbol.start, symbol.end))
-        .with("selectionRange", locationsToLspRange(js, symbol.selectionStart, symbol.selectionEnd))
-        .with("children", js.array(symbol.children.map {documentSymbolToLsp(js, _)}))
+        .with("range", locationsToLspRange(symbol.start, symbol.end))
+        .with("selectionRange", locationsToLspRange(symbol.selectionStart, symbol.selectionEnd))
+        .with("children", symbol.children.toArray().map {documentSymbolToLsp(_)})
 }
 
-workspaceSymbolToLsp(js: JsSystem, rootPath: Path, symbol: WorkspaceSymbol): JsValue {
-    let o = js.object()
+workspaceSymbolToLsp(rootPath: Path, symbol: WorkspaceSymbol): Json {
+    let o = Json.object()
         .with("name", symbol.name)
         .with("kind", symbol.kind)
-        .with("location", js.object()
+        .with("location", Json.object()
             .with("uri", rootPath.path(symbol.selectionStart.file).url())
-            .with("range", locationsToLspRange(js, symbol.selectionStart, symbol.selectionEnd))
+            .with("range", locationsToLspRange(symbol.selectionStart, symbol.selectionEnd))
         )
     symbol.containerName.{
         | Some(n) => o.with("containerName", n)
@@ -113,13 +113,13 @@ workspaceSymbolToLsp(js: JsSystem, rootPath: Path, symbol: WorkspaceSymbol): JsV
     }   
 }
 
-locationsToLspRange(js: JsSystem, start: Location, end: Location): JsValue {
-    js.object()
-        .with("start", js.object()
+locationsToLspRange(start: Location, end: Location): Json {
+    Json.object()
+        .with("start", Json.object()
             .with("line", start.line - 1)
             .with("character", start.column - 1)
         )
-        .with("end", js.object()
+        .with("end", Json.object()
             .with("line", end.line - 1)
             .with("character", end.column - 1)
         )

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

@@ -313,6 +313,14 @@ export function Array_map(self_, body_) {
         
 }
 
+export function Array_flatMap(self_, body_) {
+const results_ = ff_core_Stack.make_();
+ff_core_Array.Array_each(self_, ((x_) => {
+ff_core_Stack.Stack_pushArray(results_, body_(x_))
+}));
+return ff_core_Stack.Stack_drain(results_)
+}
+
 export function Array_sortBy(self_, body_, ff_core_Ordering_Order$S) {
 return ff_core_Array.Array_sortWith(self_, ((_w1, _w2) => {
 return ff_core_Ordering_Order$S.compare_(body_(_w1), body_(_w2))
@@ -476,6 +484,14 @@ export async function Array_map$(self_, body_, $task) {
         
 }
 
+export async function Array_flatMap$(self_, body_, $task) {
+const results_ = ff_core_Stack.make_();
+(await ff_core_Array.Array_each$(self_, (async (x_, $task) => {
+ff_core_Stack.Stack_pushArray(results_, (await body_(x_, $task)))
+}), $task));
+return ff_core_Stack.Stack_drain(results_)
+}
+
 export async function Array_sortBy$(self_, body_, ff_core_Ordering_Order$S, $task) {
 return (await ff_core_Array.Array_sortWith$(self_, (async (_w1, _w2, $task) => {
 return ff_core_Ordering_Order$S.compare_((await body_(_w1, $task)), (await body_(_w2, $task)))