firefly-compiler 0.5.38 → 0.5.40

package/lsp/LanguageServer.ff

@@ -1,272 +1,272 @@
-import ModuleCache from ff:compiler
-import DependencyLock from ff:compiler
-import Handler
-
-class LanguageServer(
-    mutable openFiles: Map[String, String]
-)
-
-data BadRequestException(reason: String)
-
-data Request(
-    headers: Map[String, String]
-    object: Json
-)
-
-data RequestMessage(
-    id: Option[MessageId] // None when the request is a Notification Message
-    method: String
-    parameters: Map[String, Json]
-)
-
-logMessages = False
-
-main(system: NodeSystem) {
-    let logDirectory = if(logMessages) {
-        let directory = system.path(".").slash("messages")
-        if(directory.isDirectory()) {directory.delete()}
-        directory.createDirectory()
-        directory
-    }
-    
-    let fireflyPath = system.path(".")
-    let cache = ModuleCache.new(0)
-    let handler = Handler(
-        fireflyPath = fireflyPath
-        rootPath = None
-        virtualFiles = Map.new()
-        cancelledRequests = [].toSet()
-        responseCache = Map.new()
-        fileSymbolsCache = Map.new()
-        moduleCache = cache
-        dependencyLock = DependencyLock.new(system.mainTask())
-    )
-    try {
-        mutable input = system.readStream()
-        let responseChannel: Channel[Pair[Json, String]] = system.mainTask().channel()
-        system.mainTask().spawn {_ =>
-            while {True} {
-                let body = responseChannel.read()
-                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)
-            }
-        }
-        taskGroup(system.mainTask()) {spawn, abort =>
-            mutable version = 1
-            while {True} {
-                version += 1
-                let requestPair = parseRequest(system, input)
-                input = requestPair.second
-                let request = requestPair.first
-                let message = parseRequestMessage(request.object)
-                logDirectory.each {logMessage(_, "request", request.object, message.method)}
-                spawn(message.id) {_ =>
-                    if(message.method == "$/cancelRequest") {
-                        abort(Some(parseMessageId(message.parameters.grab("id"))))
-                    }
-                    try {
-                        handleRequestMessage(system, handler, message, version).each {body =>
-                            responseChannel.write(Pair(body, message.method))
-                        }
-                    } catchAny {error =>
-                        let problem = if(error.name() == "AbortError") {
-                            Error(-32800, "Request cancelled")
-                        } else {
-                            Log.trace("ERROR: " + error.message())
-                            Log.trace(error.stack())
-                            Error(-32603, "Internal error")
-                        }
-                        message.id.each {id => 
-                            let body = makeResponseMessage(id, problem)
-                            responseChannel.write(Pair(body, message.method))
-                        }
-                    }
-                }
-            }
-        }
-    } catch {| BadRequestException(reason), error =>
-        Log.trace(reason)
-    }
-}
-
-taskGroup[K: Order, R](
-    parentTask: Task, 
-    groupBody: ((K, Task => Unit) => Task, K => Unit) => R
-): R {
-    let lock = parentTask.lock()
-    mutable tasks = [].toMap()
-    function spawn(key: K, body: Task => Unit): Task {
-        let body2 = {task =>
-            lock.do {tasks = tasks.add(key, task)}
-            try {
-                body(task)
-            } finally {
-                lock.do {tasks = tasks.remove(key)}
-            }
-        }
-        parentTask.spawn(body2)
-    }
-    function abort(key: K): Unit {
-        lock.do {tasks.get(key).each {_.abort()}}
-    }
-    groupBody(spawn, abort)
-}
-
-parseRequest(system: NodeSystem, input: Stream[Buffer]): Pair[Request, Stream[Buffer]] {
-    let headersPair = parseRequestHeaders(input)
-    let headers = headersPair.first
-    let contentLength = headers
-        .get("content-length").else {throw(BadRequestException("'content-length' header is missing"))}
-        .trim().getInt().else {throw(BadRequestException("Value for 'content-length' is not an integer"))}
-    let bodyPair = parseRequestBody(contentLength, headersPair.second)
-    bodyPair.mapFirst {body => Request(headers, body)}
-}
-
-parseRequestHeaders(input: Stream[Buffer]): Pair[Map[String, String], Stream[Buffer]] {
-    let buffers = Array.new()
-    mutable buffer = input.next().else {
-        throw(BadRequestException("End of input while parsing request headers"))
-    }
-    mutable offset = 0
-    mutable droppingInitialNewlines = True
-    mutable lastWasNewline = False
-    mutable done = False
-    while {!done} {
-        if(offset == buffer.size()) {
-            offset = 0
-            buffers.push(buffer)
-            buffer = input.next().else {
-                throw(BadRequestException("End of input while parsing request headers"))
-            }
-        }
-        let byte = buffer.grabUint8(offset)
-        if(droppingInitialNewlines && (byte == '\n'.codeUnit || byte == '\r'.codeUnit)) {
-            // Skip
-        } elseIf {byte == '\n'.codeUnit} {
-            if(lastWasNewline) {
-                done = True
-            } else {
-                lastWasNewline = True
-            }
-        } elseIf {byte != '\r'.codeUnit && lastWasNewline} {
-            lastWasNewline = False
-        } else {
-            droppingInitialNewlines = False
-        }
-        offset += 1
-    }
-    buffers.push(buffer.view(0, offset))
-    let headers = Buffer.fromBufferList(buffers.drain()).toString()
-    let map = headers.lines().pairs().filter {_.second.size() != 0}.map {| Pair(i, line) =>
-        line.splitFirst(':').else {
-            throw(BadRequestException("Invalid header at line " + i + " '" + line + "'"))
-        }.mapFirst {_.lower()} //.mapSecond {_.trim()}
-    }.toMap()
-    Pair(map, [buffer.view(offset, buffer.size())].toStream().addAll(input))
-}
-
-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"))
-    }
-    let body = Buffer.fromBufferList(bodyPair.first).toString()
-    let json = Json.read(body).else {
-        throw(BadRequestException("Invalid JSON in request body: " + body))
-    }
-    Pair(json, bodyPair.second)
-}
-
-parseRequestMessage(object: Json): RequestMessage {
-    let id = object.getField("id").map {parseMessageId(_)}
-
-    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.getField("params").{
-        | None => [].toMap()
-        | Some(o) {!o.isObject()} => throw(BadRequestException("Bad JSON-RPC params, object expected"))
-        | Some(o) => o.grabMap()
-    }
-
-    RequestMessage(id, method, parameters)
-}
-
-parseMessageId(id: Json): MessageId {
-    if(id.isInt()) {
-        MessageIdInt(id.grabInt())
-    } elseIf {id.isString()} {
-        MessageIdString(id.grabString())
-    } else {
-        throw(BadRequestException("Bad JSON-RPC id, int or string expected"))
-    }
-}
-
-handleRequestMessage(system: NodeSystem, handler: Handler, message: RequestMessage, version: Int): List[Json] {
-    try {
-        message.id.{
-            | None {message.method == "$/cancelRequest"} => // TODO: Needs to read ahead to cancel anything
-                handler.cancelledRequests = handler.cancelledRequests.add(
-                    parseMessageId(message.parameters.grab("id"))
-                )
-                []
-            | None => 
-                let notification = handler.handleNotification(system, message.method, message.parameters, version)
-                notification.map {| Pair(method, params) => makeNotificationMessage(method, params)}
-            | Some(id) {handler.cancelledRequests.contains(id)} =>
-                handler.cancelledRequests = handler.cancelledRequests.remove(id)
-                [makeResponseMessage(id, Error(-32800, "Request cancelled"))]
-            | Some(id) =>
-                let result = handler.handleRequest(system, message.method, message.parameters, version)
-                [makeResponseMessage(id, result)]
-        }
-    } catchAny {error =>
-        //system.files().writeText("lsp-failure.txt", error.name() + ": " + error.message())
-        error.rethrow()
-    }
-}
-
-makeResponseMessage(id: MessageId, result: ResultOrError): Json {
-    mutable o = Json.object().with("jsonrpc", "2.0")
-    id.{
-        | MessageIdInt(id) => o = o.with("id", id)
-        | MessageIdString(id) => o = o.with("id", id)
-    }
-    result.{
-        | Result(result) =>
-            o = o.with("result", Json.read(result).grab())
-        | Error(code, message) =>
-            let e = Json.object()
-                .with("code", code)
-                .with("message", message)
-            o = o.with("error", e)
-    }
-    o
-}
-
-makeNotificationMessage(method: String, params: Json): Json {
-    Json.object()
-        .with("jsonrpc", "2.0")
-        .with("method", method)
-        .with("params", params)
-}
-
-logMessage(directory: Path, messageType: String, body: Json, method: String) {
-    let id = if(method == "$/cancelRequest") {
-        Some(body.field("params").field("id").grabInt())
-    } else {
-        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.write(Some("    ")))
-}
+import ModuleCache from ff:compiler
+import DependencyLock from ff:compiler
+import Handler
+
+class LanguageServer(
+    mutable openFiles: Map[String, String]
+)
+
+data BadRequestException(reason: String)
+
+data Request(
+    headers: Map[String, String]
+    object: Json
+)
+
+data RequestMessage(
+    id: Option[MessageId] // None when the request is a Notification Message
+    method: String
+    parameters: Map[String, Json]
+)
+
+logMessages = False
+
+main(system: NodeSystem) {
+    let logDirectory = if(logMessages) {
+        let directory = system.path(".").slash("messages")
+        if(directory.isDirectory()) {directory.delete()}
+        directory.createDirectory()
+        directory
+    }
+    
+    let fireflyPath = system.path(".")
+    let cache = ModuleCache.new(0)
+    let handler = Handler(
+        fireflyPath = fireflyPath
+        rootPath = None
+        virtualFiles = Map.new()
+        cancelledRequests = [].toSet()
+        responseCache = Map.new()
+        fileSymbolsCache = Map.new()
+        moduleCache = cache
+        dependencyLock = DependencyLock.new(system.mainTask())
+    )
+    try {
+        mutable input = system.readStream()
+        let responseChannel: Channel[Pair[Json, String]] = system.mainTask().channel()
+        system.mainTask().spawn {_ =>
+            while {True} {
+                let body = responseChannel.read()
+                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)
+            }
+        }
+        taskGroup(system.mainTask()) {spawn, abort =>
+            mutable version = 1
+            while {True} {
+                version += 1
+                let requestPair = parseRequest(system, input)
+                input = requestPair.second
+                let request = requestPair.first
+                let message = parseRequestMessage(request.object)
+                logDirectory.each {logMessage(_, "request", request.object, message.method)}
+                spawn(message.id) {_ =>
+                    if(message.method == "$/cancelRequest") {
+                        abort(Some(parseMessageId(message.parameters.grab("id"))))
+                    }
+                    try {
+                        handleRequestMessage(system, handler, message, version).each {body =>
+                            responseChannel.write(Pair(body, message.method))
+                        }
+                    } catchAny {error =>
+                        let problem = if(error.name() == "AbortError") {
+                            Error(-32800, "Request cancelled")
+                        } else {
+                            Log.trace("ERROR: " + error.message())
+                            Log.trace(error.stack())
+                            Error(-32603, "Internal error")
+                        }
+                        message.id.each {id => 
+                            let body = makeResponseMessage(id, problem)
+                            responseChannel.write(Pair(body, message.method))
+                        }
+                    }
+                }
+            }
+        }
+    } catch {| BadRequestException(reason), error =>
+        Log.trace(reason)
+    }
+}
+
+taskGroup[K: Order, R](
+    parentTask: Task, 
+    groupBody: ((K, Task => Unit) => Task, K => Unit) => R
+): R {
+    let lock = parentTask.lock()
+    mutable tasks = [].toMap()
+    function spawn(key: K, body: Task => Unit): Task {
+        let body2 = {task =>
+            lock.do {tasks = tasks.add(key, task)}
+            try {
+                body(task)
+            } finally {
+                lock.do {tasks = tasks.remove(key)}
+            }
+        }
+        parentTask.spawn(body2)
+    }
+    function abort(key: K): Unit {
+        lock.do {tasks.get(key).each {_.abort()}}
+    }
+    groupBody(spawn, abort)
+}
+
+parseRequest(system: NodeSystem, input: Stream[Buffer]): Pair[Request, Stream[Buffer]] {
+    let headersPair = parseRequestHeaders(input)
+    let headers = headersPair.first
+    let contentLength = headers
+        .get("content-length").else {throw(BadRequestException("'content-length' header is missing"))}
+        .trim().getInt().else {throw(BadRequestException("Value for 'content-length' is not an integer"))}
+    let bodyPair = parseRequestBody(contentLength, headersPair.second)
+    bodyPair.mapFirst {body => Request(headers, body)}
+}
+
+parseRequestHeaders(input: Stream[Buffer]): Pair[Map[String, String], Stream[Buffer]] {
+    let buffers = Array.new()
+    mutable buffer = input.next().else {
+        throw(BadRequestException("End of input while parsing request headers"))
+    }
+    mutable offset = 0
+    mutable droppingInitialNewlines = True
+    mutable lastWasNewline = False
+    mutable done = False
+    while {!done} {
+        if(offset == buffer.size()) {
+            offset = 0
+            buffers.push(buffer)
+            buffer = input.next().else {
+                throw(BadRequestException("End of input while parsing request headers"))
+            }
+        }
+        let byte = buffer.grabUint8(offset)
+        if(droppingInitialNewlines && (byte == '\n'.codeUnit || byte == '\r'.codeUnit)) {
+            // Skip
+        } elseIf {byte == '\n'.codeUnit} {
+            if(lastWasNewline) {
+                done = True
+            } else {
+                lastWasNewline = True
+            }
+        } elseIf {byte != '\r'.codeUnit && lastWasNewline} {
+            lastWasNewline = False
+        } else {
+            droppingInitialNewlines = False
+        }
+        offset += 1
+    }
+    buffers.push(buffer.view(0, offset))
+    let headers = Buffer.fromBufferList(buffers.drain()).toString()
+    let map = headers.lines().pairs().filter {_.second.size() != 0}.map {| Pair(i, line) =>
+        line.splitFirst(':').else {
+            throw(BadRequestException("Invalid header at line " + i + " '" + line + "'"))
+        }.mapFirst {_.lower()} //.mapSecond {_.trim()}
+    }.toMap()
+    Pair(map, [buffer.view(offset, buffer.size())].toStream().addAll(input))
+}
+
+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"))
+    }
+    let body = Buffer.fromBufferList(bodyPair.first).toString()
+    let json = Json.read(body).else {
+        throw(BadRequestException("Invalid JSON in request body: " + body))
+    }
+    Pair(json, bodyPair.second)
+}
+
+parseRequestMessage(object: Json): RequestMessage {
+    let id = object.getField("id").map {parseMessageId(_)}
+
+    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.getField("params").{
+        | None => [].toMap()
+        | Some(o) {!o.isObject()} => throw(BadRequestException("Bad JSON-RPC params, object expected"))
+        | Some(o) => o.grabMap()
+    }
+
+    RequestMessage(id, method, parameters)
+}
+
+parseMessageId(id: Json): MessageId {
+    if(id.isInt()) {
+        MessageIdInt(id.grabInt())
+    } elseIf {id.isString()} {
+        MessageIdString(id.grabString())
+    } else {
+        throw(BadRequestException("Bad JSON-RPC id, int or string expected"))
+    }
+}
+
+handleRequestMessage(system: NodeSystem, handler: Handler, message: RequestMessage, version: Int): List[Json] {
+    try {
+        message.id.{
+            | None {message.method == "$/cancelRequest"} => // TODO: Needs to read ahead to cancel anything
+                handler.cancelledRequests = handler.cancelledRequests.add(
+                    parseMessageId(message.parameters.grab("id"))
+                )
+                []
+            | None => 
+                let notification = handler.handleNotification(system, message.method, message.parameters, version)
+                notification.map {| Pair(method, params) => makeNotificationMessage(method, params)}
+            | Some(id) {handler.cancelledRequests.contains(id)} =>
+                handler.cancelledRequests = handler.cancelledRequests.remove(id)
+                [makeResponseMessage(id, Error(-32800, "Request cancelled"))]
+            | Some(id) =>
+                let result = handler.handleRequest(system, message.method, message.parameters, version)
+                [makeResponseMessage(id, result)]
+        }
+    } catchAny {error =>
+        //system.files().writeText("lsp-failure.txt", error.name() + ": " + error.message())
+        error.rethrow()
+    }
+}
+
+makeResponseMessage(id: MessageId, result: ResultOrError): Json {
+    mutable o = Json.object().with("jsonrpc", "2.0")
+    id.{
+        | MessageIdInt(id) => o = o.with("id", id)
+        | MessageIdString(id) => o = o.with("id", id)
+    }
+    result.{
+        | Result(result) =>
+            o = o.with("result", Json.read(result).grab())
+        | Error(code, message) =>
+            let e = Json.object()
+                .with("code", code)
+                .with("message", message)
+            o = o.with("error", e)
+    }
+    o
+}
+
+makeNotificationMessage(method: String, params: Json): Json {
+    Json.object()
+        .with("jsonrpc", "2.0")
+        .with("method", method)
+        .with("params", params)
+}
+
+logMessage(directory: Path, messageType: String, body: Json, method: String) {
+    let id = if(method == "$/cancelRequest") {
+        Some(body.field("params").field("id").grabInt())
+    } else {
+        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.write(Some("    ")))
+}

package/lsp/SignatureHelpHandler.ff

@@ -1,55 +1,55 @@
-import LspHook from ff:compiler
-import Unification from ff:compiler
-import Environment from ff:compiler
-import Syntax from ff:compiler
-import Handler
-import CompletionHandler
-
-handleSignatureHelp(system: NodeSystem, lspHook: LspHook): Json {
-    let signatureAndUnification = lspHook.results().collectFirst {
-        | InferLookupHook h => 
-            let isMember = h.symbol.value.qualifiedName.contains("_")
-            h.instantiated.value.map {i =>
-                let signature = if(!isMember) {i.scheme.signature} else {
-                    i.scheme.signature.Signature(parameters = i.scheme.signature.parameters.dropFirst())
-                }
-                Pair(signature, h.unification)
-            }
-        | _ => None
-    }
-    signatureAndUnification.map {| Pair(s, unification) => 
-        let shownTypes = [...s.parameters.map {_.valueType}, s.returnType].map {unification.substitute(_)}
-        let realGenerics = s.generics.filter {_ != "Q$"}
-        let generics = if(realGenerics.isEmpty()) {""} else {"[" + realGenerics.join(", ") + "]"}
-        // TODO only instantiate acording to self. Eg. Some("foo").map {...}
-        let parameters = s.parameters.map {p => 
-            CompletionHandler.showCompletionParameter("", p.Parameter(valueType = unification.substitute(p.valueType)))
-        }
-        let label = 
-            s.name + generics + "(" + parameters.join(", ") + "): " + unification.substitute(s.returnType).show(shownTypes)
-        Json.object()
-            .with("signatures", [Json.object()
-                .with("label", label)
-                .with("parameters", [
-                    ...parameters.map {p => 
-                        Json.object().with("label", p)
-                    }
-                    // Fake parameter to trick the client into remembering the call position
-                    Json.object().with("label", "/* Call " + lspHook.at.show() + " */")
-                ])
-            ])
-            .with("activeSignature", 0)
-    }.else {Json.null()}
-}
-
-pickActiveParameter(help: Json, argumentIndex: Int, parameterName: Option[String]): Json {
-    parameterName.flatMap {name =>
-        help.field("signatures").index(0).field("parameters").getArray().flatMap {parameters =>
-            parameters.pairs().collectFirst {| Pair(i, p) => 
-                if(name == p.field("label").grabString().takeWhile {_.isAsciiLetterOrDigit()}) {
-                    help.with("activeParameter", i)
-                }
-            }
-        }
-    }.else {help.with("activeParameter", argumentIndex)}
-}
+import LspHook from ff:compiler
+import Unification from ff:compiler
+import Environment from ff:compiler
+import Syntax from ff:compiler
+import Handler
+import CompletionHandler
+
+handleSignatureHelp(system: NodeSystem, lspHook: LspHook): Json {
+    let signatureAndUnification = lspHook.results().collectFirst {
+        | InferLookupHook h => 
+            let isMember = h.symbol.value.qualifiedName.contains("_")
+            h.instantiated.value.map {i =>
+                let signature = if(!isMember) {i.scheme.signature} else {
+                    i.scheme.signature.Signature(parameters = i.scheme.signature.parameters.dropFirst())
+                }
+                Pair(signature, h.unification)
+            }
+        | _ => None
+    }
+    signatureAndUnification.map {| Pair(s, unification) => 
+        let shownTypes = [...s.parameters.map {_.valueType}, s.returnType].map {unification.substitute(_)}
+        let realGenerics = s.generics.filter {_ != "Q$"}
+        let generics = if(realGenerics.isEmpty()) {""} else {"[" + realGenerics.join(", ") + "]"}
+        // TODO only instantiate acording to self. Eg. Some("foo").map {...}
+        let parameters = s.parameters.map {p => 
+            CompletionHandler.showCompletionParameter("", p.Parameter(valueType = unification.substitute(p.valueType)))
+        }
+        let label = 
+            s.name + generics + "(" + parameters.join(", ") + "): " + unification.substitute(s.returnType).show(shownTypes)
+        Json.object()
+            .with("signatures", [Json.object()
+                .with("label", label)
+                .with("parameters", [
+                    ...parameters.map {p => 
+                        Json.object().with("label", p)
+                    }
+                    // Fake parameter to trick the client into remembering the call position
+                    Json.object().with("label", "/* Call " + lspHook.at.show() + " */")
+                ])
+            ])
+            .with("activeSignature", 0)
+    }.else {Json.null()}
+}
+
+pickActiveParameter(help: Json, argumentIndex: Int, parameterName: Option[String]): Json {
+    parameterName.flatMap {name =>
+        help.field("signatures").index(0).field("parameters").getArray().flatMap {parameters =>
+            parameters.pairs().collectFirst {| Pair(i, p) => 
+                if(name == p.field("label").grabString().takeWhile {_.isAsciiLetterOrDigit()}) {
+                    help.with("activeParameter", i)
+                }
+            }
+        }
+    }.else {help.with("activeParameter", argumentIndex)}
+}