firefly-compiler 0.4.4

package/lsp/LanguageServer.ff

@@ -0,0 +1,229 @@
+import Handler
+
+class LanguageServer(
+    mutable openFiles: Map[String, String]
+)
+
+data BadRequestException(reason: String)
+
+capability Request(
+    headers: Map[String, String]
+    object: JsValue
+)
+
+capability RequestMessage(
+    id: Option[MessageId] // None when the request is a Notification Message
+    method: String
+    parameters: Map[String, JsValue]
+)
+
+
+main(system: NodeSystem) {
+    let fireflyPath = system.path(".")
+    let handler = Handler(fireflyPath, None, Map.empty(), [].toSet(), Map.empty(), Map.empty())
+    try {
+        mutable input = system.readStream()
+        let responseChannel: Channel[JsValue] = system.mainTask().channel()
+        system.mainTask().spawn {_ =>
+            while {True} {
+                let body = responseChannel.read()
+                let json = body.toJson(Some("    ")).toBuffer()
+                system.writeText("Content-Length: " + json.size() + "\r\n\r\n")
+                system.writeBuffer(json)
+            }
+        }
+        taskGroup(system.mainTask()) {spawn, abort =>
+            while {True} {
+                let requestPair = parseRequest(system, input)
+                input = requestPair.second
+                let request = requestPair.first
+                let message = parseRequestMessage(request.object)
+                spawn(message.id) {_ =>
+                    if(message.method == "$/cancelRequest") {
+                        abort(Some(parseMessageId(message.parameters.grab("id"))))
+                    }
+                    try {
+                        handleRequestMessage(system, handler, message).each {body =>
+                            responseChannel.write(body)
+                        }
+                    } 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 => 
+                            responseChannel.write(makeResponseMessage(system.js(), id, problem))
+                        }
+                    } grab()
+                }
+            }
+        }
+    } catch {| BadRequestException(reason), error =>
+        Log.trace(reason)
+    } grab()
+}
+
+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)}
+            } grab()
+        }
+        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"))}
+        .getInt().else {throw(BadRequestException("Value for 'content-length' is not an integer"))}
+    let bodyPair = parseRequestBody(system.js(), contentLength, headersPair.second)
+    bodyPair.mapFirst {body => Request(headers, body)}
+}
+
+parseRequestHeaders(input: Stream[Buffer]): Pair[Map[String, String], Stream[Buffer]] {
+    let buffers = Stack.make()
+    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.fromBufferArray(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(js: JsSystem, contentLength: Int, input: Stream[Buffer]): Pair[JsValue, 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 =>
+        throw(BadRequestException("Invalid JSON in request body: " + body))
+    } grab()
+    Pair(json, bodyPair.second)
+}
+
+parseRequestMessage(object: JsValue): RequestMessage {
+    let id = object.getOwn("id").map {parseMessageId(_)}
+
+    let method = object.getOwn("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").{
+        | None => [].toMap()
+        | Some(o) {!o.isObject()} => throw(BadRequestException("Bad JSON-RPC params, object expected"))
+        | Some(o) => o.grabMap()
+    }
+
+    RequestMessage(id, method, parameters)
+}
+
+parseMessageId(id: JsValue): 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): Option[JsValue] {
+    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
+            | None => 
+                handler.handleNotification(system, message.method, message.parameters)
+                None
+            | Some(id) {handler.cancelledRequests.contains(id)} =>
+                handler.cancelledRequests = handler.cancelledRequests.remove(id)
+                Some(makeResponseMessage(system.js(), id, Error(-32800, "Request cancelled")))
+            | Some(id) =>
+                let result = handler.handleRequest(system, message.method, message.parameters)
+                Some(makeResponseMessage(system.js(), id, result))
+        }
+    } catchAny {error =>
+        //system.files().writeText("lsp-failure.txt", error.name() + ": " + error.message())
+        error.rethrow()
+    } grab()
+}
+
+makeResponseMessage(js: JsSystem, id: MessageId, result: ResultOrError): JsValue {
+    let o = js.object()
+    o.set("jsonrpc", "2.0")
+    id.{
+        | MessageIdInt(id) => o.set("id", id)
+        | MessageIdString(id) => o.set("id", id)
+    }
+    result.{
+        | Result(result) =>
+            o.set("result", js.parseJson(result))
+        | Error(code, message) =>
+            let e = js.object()
+            e.set("code", code)
+            e.set("message", message)
+            o.set("error", e)
+    }
+    o
+}

package/lsp/SignatureHelpHandler.ff

@@ -0,0 +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): JsValue {
+    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
+    }
+    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$"}
+        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)
+        js.object()
+            .with("signatures", js.array([js.object()
+                .with("label", label)
+                .with("parameters", js.array([
+                    ...parameters.map {p => 
+                        js.object().with("label", p)
+                    }
+                    // Fake parameter to trick the client into remembering the call position
+                    js.object().with("label", "/* Call " + lspHook.at.show() + " */")
+                ]))
+            ]))
+            .with("activeSignature", 0)
+    }.else {js.null()}
+}
+
+pickActiveParameter(help: JsValue, argumentIndex: Int, parameterName: Option[String]): JsValue {
+    parameterName.flatMap {name =>
+        let parameters = help.get("signatures").get(0).get("parameters").grabArray().toList()
+        parameters.pairs().collectFirst {| Pair(i, p) => 
+            if(name == p.get("label").grabString().takeWhile {_.isAsciiLetterOrDigit()}) {
+                help.with("activeParameter", i)
+            }
+        }
+    }.else {help.with("activeParameter", argumentIndex)}
+}

package/lsp/SymbolHandler.ff

@@ -0,0 +1,167 @@
+import LspHook from ff:compiler
+import Syntax from ff:compiler
+
+data DocumentSymbol(
+    name: String
+    kind: Int
+    selectionStart: Location
+    selectionEnd: Location
+    start: Location
+    end: Location
+    children: List[DocumentSymbol]
+)
+
+data WorkspaceSymbol(
+    name: String
+    kind: Int
+    containerName: Option[String]
+    selectionStart: Location
+    selectionEnd: Location
+)
+
+class Result[T](
+    result: T
+    remaining: List[ResultHook]
+)
+
+data ReadSymbolsError()
+
+readAllSymbols(hooks: List[ResultHook]): List[DocumentSymbol]  {
+    let result = readSymbols(hooks)
+    if(!result.remaining.isEmpty()) {throw(ReadSymbolsError())}
+    result.result
+}
+
+readSymbols(hooks: List[ResultHook]): Result[List[DocumentSymbol]]  {
+    | [ParseSymbolBegin, ...rest] => 
+        let symbol = readSymbol(rest)
+        let symbols = readSymbols(symbol.remaining)
+        Result([symbol.result, ...symbols.result], symbols.remaining)
+    | _ => Result([], hooks)
+}
+
+readSymbol(hooks: List[ResultHook]): Result[DocumentSymbol] {
+    let children = readSymbols(hooks)
+    children.remaining.{
+        | [ParseSymbolEnd(name, kind, selectionStart, selectionEnd, start, end), ...rest] => 
+            let symbol = DocumentSymbol(name, kind, selectionStart, selectionEnd, start, end, children.result)
+            Result(symbol, rest)
+        | _ => throw(ReadSymbolsError())
+        }
+}
+
+handleDocumentSymbol(system: NodeSystem, resultHooks: List[ResultHook]): List[JsValue] {
+    let symbols = readAllSymbols(resultHooks)
+    symbols.map {documentSymbolToLsp(system.js(), _)}
+}
+
+handleWorkspaceSymbol(system: NodeSystem, resultHooks: List[ResultHook], query: String): List[JsValue] {
+    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("."), _)}
+    //workspaceSymbolsJs.each {Log.trace(_.toJson(None))}
+    jsSymbols
+}
+
+documentToWorkspaceSymbols(symbol: DocumentSymbol, parentName: Option[String]): List[WorkspaceSymbol] {
+    let s = WorkspaceSymbol(
+        symbol.name
+        kind = symbol.kind
+        containerName = parentName
+        selectionStart = symbol.selectionEnd
+        selectionEnd = symbol.selectionEnd
+    )
+    let children = symbol.children.flatMap {documentToWorkspaceSymbols(_, Some(symbol.name))}
+    [s, ... children]
+}
+
+showHook(lspHook: ResultHook): String {
+    | ParseSymbolBegin => "ParseSymbolBegin"
+    | ParseSymbolEnd(name, kind, _, _, _, _) => "ParseSymbolEnd("+Show.show(name)+", "+Show.show(kind)+")"
+    //| ParseSymbolBegin => "("
+    //| ParseSymbolEnd(name, kind, symbolStart, selectionStart, selectionEnd) => ") " + name + " " + showPosition(selectionStart) + " - " + showPosition(selectionEnd)
+    | _ => "other"
+}
+
+showPosition(at: Location): String {
+    at.line + ":" + at.column
+}
+
+documentSymbolToLsp(js: JsSystem, symbol: DocumentSymbol): JsValue {
+    js.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, _)}))
+}
+
+workspaceSymbolToLsp(js: JsSystem, rootPath: Path, symbol: WorkspaceSymbol): JsValue {
+    let o = js.object()
+        .with("name", symbol.name)
+        .with("kind", symbol.kind)
+        .with("location", js.object()
+            .with("uri", rootPath.path(symbol.selectionStart.file).url())
+            .with("range", locationsToLspRange(js, symbol.selectionStart, symbol.selectionEnd))
+        )
+    symbol.containerName.{
+        | Some(n) => o.with("containerName", n)
+        | None => o
+    }   
+}
+
+locationsToLspRange(js: JsSystem, start: Location, end: Location): JsValue {
+    js.object()
+        .with("start", js.object()
+            .with("line", start.line - 1)
+            .with("character", start.column - 1)
+        )
+        .with("end", js.object()
+            .with("line", end.line - 1)
+            .with("character", end.column - 1)
+        )
+}
+
+symbolFilter(symbol: WorkspaceSymbol, query: String): Bool {
+    let symbolWords = splitCamelCased(symbol.name.takeWhile {_.isAsciiLetterOrDigit()})
+    matchSymbol(symbolWords, query)
+}
+
+matchSymbol(symbolWords: List[String], query: String): Bool {
+    let memo = IntMap.make()
+    function go(wordIndex: Int, queryOffset: Int): Bool {
+        memo.getOrSet(wordIndex) {IntMap.make()}.getOrSet(queryOffset):
+        if(queryOffset >= query.size()) {True} else:
+        if(wordIndex >= symbolWords.size()) {False} else:
+        prefixes(query.dropFirst(queryOffset)).any {prefix => 
+            symbolWords.grab(wordIndex).startsWith(prefix) && 
+            go(wordIndex + 1, queryOffset + prefix.size())
+        }
+    }
+    go(0, 0)
+}
+
+prefixes(string: String): List[String] {
+    if(string == "") {[""]} else:
+    function go(rest: String): List[String] {
+        if(rest == "") {
+            [""]
+        } else {
+            [rest, ...go(rest.dropLast())]
+        }
+    }
+    go(string.grab(0).toString().lower() + string.dropFirst().takeWhile {!_.isAsciiUpper()})
+}
+
+splitCamelCased(name: String): List[String] {
+    name.first().{
+        | None => []
+        | Some(c) => 
+            let word = c.toString().lower() + name.dropFirst().takeWhile {_.isAsciiLower()}
+            let rest = name.dropFirst(word.size())
+            [word, ...splitCamelCased(rest)]
+    }
+}