firefly-compiler 0.4.4

package/lsp/Handler.ff

@@ -0,0 +1,551 @@
+import JsEmitter from ff:compiler
+import Builder from ff:compiler
+import Syntax from ff:compiler
+import Tokenizer from ff:compiler
+import Parser from ff:compiler
+import Token from ff:compiler
+import Environment from ff:compiler
+import Unification from ff:compiler
+import LspHook from ff:compiler
+import HoverHandler
+import CompletionHandler
+import SignatureHelpHandler
+import SymbolHandler
+
+capability Handler(
+    fireflyPath: Path
+    mutable rootPath: Option[Path]
+    mutable virtualFiles: Map[String, String]
+    mutable cancelledRequests: Set[MessageId]
+    mutable responseCache: Map[Pair[String, Location], ResultOrError]
+    mutable fileSymbolsCache: Map[String, List[DocumentSymbol]]
+)
+
+data MessageId {
+    MessageIdInt(id: Int)
+    MessageIdString(id: String)
+}
+
+data ResultOrError {
+    Result(result: String)
+    Error(code: Int, message: String)
+}
+
+data LanguageServerException(message: String)
+
+data TokenLocation(
+    file: String
+    startLine: Int
+    startColumn: Int
+    endLine: Int
+    endColumn: Int
+    raw: String
+    followedByLeftBracket: Bool
+)
+
+
+extend self: Handler {
+
+    handleNotification(system: NodeSystem, method: String, parameters: Map[String, JsValue]): Unit {
+        method.{
+            | "initialized" =>
+            | "textDocument/didChange" => 
+                self.handleDidChange(system, parameters)
+            | "textDocument/didClose" => self.handleDidClose(system, parameters)
+            | "exit" => system.exit(0)
+            | _ =>
+        }
+    }
+
+    handleRequest(system: NodeSystem, method: String, parameters: Map[String, JsValue]): ResultOrError {
+        method.{
+            | "initialize" => self.handleInitialize(system, parameters)
+            | "textDocument/diagnostic" => self.handleDiagnostic(system, parameters)
+            | "textDocument/documentSymbol" => self.handleDocumentSymbol(system, parameters)
+            | "textDocument/completion" => self.handleCompletion(system, parameters)
+            | "textDocument/signatureHelp" => self.handleSignatureHelp(system, parameters)
+            | "textDocument/hover" => 
+                self.handleTokenRequestWithCache(system, method, parameters) {targetAt => 
+                    self.handleHover(system, targetAt, goToDefinition = False)
+                }
+            | "textDocument/definition" => 
+                self.handleTokenRequestWithCache(system, method, parameters) {targetAt => 
+                    self.handleHover(system, targetAt, goToDefinition = True)
+                }
+            | "textDocument/references" => 
+                self.handleTokenRequestWithCache(system, method, parameters) {targetAt => 
+                    self.handleReferences(system, targetAt, local = False)
+                }
+            | "textDocument/rename" => self.handleRename(system, parameters)
+            | "textDocument/documentHighlight" => 
+                self.handleTokenRequestWithCache(system, method, parameters) {targetAt => 
+                    self.handleReferences(system, targetAt, local = True)
+                }
+            | "workspace/symbol" => self.printTime(system.mainTask(), "handleWorkspaceSymbol") {self.handleWorkspaceSymbol(system, parameters)}
+            | "shutdown" => Result(system.js().null().toJson())
+            | _ => self.handleUnsupported(system.js())
+        }
+    }
+
+    handleTokenRequestWithCache(
+        system: NodeSystem
+        method: String
+        parameters: Map[String, JsValue]
+        handle: Location => ResultOrError
+    ): ResultOrError {
+        let targetAt = self.findTokenFromParameters(system, parameters)
+        let cacheKey = Pair(method, targetAt)
+            self.responseCache.get(cacheKey).{
+                | Some(hit) => hit
+                | None => 
+                    let result = handle(targetAt)
+                    self.responseCache = self.responseCache.add(cacheKey, result)
+                    result
+            }
+    }
+
+    handleUnsupported(js: JsSystem): ResultOrError {
+        Error(1234, "Unsupported method")
+    }
+
+    handleInitialize(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+        let js = system.js()
+        self.rootPath = Some(system.pathFromUrl(parameters.grab("rootUri").grabString()))
+
+        let anyFireflyFile = js.object()
+            .with("filters", [
+                js.object()
+                    .with("pattern", js.object()
+                        .with("glob", "**/*.ff")
+                        .with("matches", "file")
+                    )
+            ].toArray())
+
+        let o = js.object()
+            .with("capabilities", js.object()
+                .with("textDocumentSync", js.object()
+                    .with("openClose", True)
+                    .with("change", 1 /* TextDocumentSyncKind.Full */)
+                )
+                .with("hoverProvider", True)
+                .with("definitionProvider", True)
+                .with("documentHighlightProvider", True)
+                .with("diagnosticProvider", js.object()
+                    .with("interFileDependencies", False)
+                    .with("workspaceDiagnostics", False)
+                )
+                .with("documentSymbolProvider", True)
+                .with("completionProvider", js.object()
+                    .with("triggerCharacters", js.array([".", " ", "("].map {js.value(_)}))
+                    .with("allCommitCharacters", js.array([";"].map {js.value(_)}))
+                )
+                .with("signatureHelpProvider", js.object()
+                    .with("triggerCharacters", js.array(["("].map {js.value(_)}))
+                    .with("retriggerCharacters", js.array([","].map {js.value(_)}))
+                )
+                .with("referencesProvider", True)
+                .with("workspaceSymbolProvider", True)
+                /*.with("workspace", js.object()
+                    .with("workspaceFolders", js.object()
+                         .with("supported", True)
+                         .with("changeNotifications", True)
+                    )
+                    .with("fileOperations", js.object()
+                         .with("didCreate", anyFireflyFile)
+                         .with("didRename", anyFireflyFile)
+                         .with("didDelete", anyFireflyFile)
+                    )
+                )*/
+                .with("renameProvider", True)
+            )
+            .with("serverInfo", js.object()
+                .with("name", "Firefly Language Server")
+                .with("version", "0.0.0")
+            )
+        Result(o.toJson())
+    }
+
+    handleDiagnostic(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+        let js = system.js()
+        let uri = parameters.grab("textDocument").get("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        let fireflyPath = system.path(".")
+        let diagnostics = try {
+            Builder.check(system, fireflyPath, path, self.virtualFiles, LspHook.disabled(), True)
+            []
+        } catch {| CompileError(at, message), error =>
+            let tokenLocation = self.findToken(system, at)
+            let diagnostic = js.object()
+                .with("range", self.tokenLocationToLspRange(js, tokenLocation))
+                .with("severity", 1 /* Error */)
+                .with("message", message)
+            [diagnostic]
+        } grab()
+
+        let o = js.object()
+            .with("kind", "full")
+            .with("items", diagnostics.toArray())
+        Result(o.toJson())
+    }
+
+    handleDocumentSymbol(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+        let js = system.js()
+        let uri = parameters.grab("textDocument").get("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        let symbols = self.getDocumentSymbolsWithCache(system, path)
+        let lspSymbols = symbols.map {SymbolHandler.documentSymbolToLsp(js, _)}
+        Result(js.array(lspSymbols).toJson())
+    }
+
+    getDocumentSymbols(system: NodeSystem, path: Path): List[DocumentSymbol] {
+        try {
+            let lspHook = LspHook.make(at = None, definedAt = None, insertIdentifier = False, trackSymbols = True)
+            let code = self.virtualFiles.get(path.absolute()).else {path.readText()}
+            let tokens = Tokenizer.tokenize(path.absolute(), code, None, True)
+            let parser = Parser.make(PackagePair("script", "script"), path.absolute(), tokens, False, lspHook)
+            parser.parseModuleWithPackageInfo()
+            SymbolHandler.readAllSymbols(lspHook.results())
+        } catch {| CompileError(at, message), error =>
+            Log.trace("handleDocumentSymbol parse error: " + message)
+            []
+        } catch {| ReadSymbolsError e, _ => 
+            Log.trace("handleDocumentSymbol ReadSymbolsError")
+            []
+        } grab()        
+    }
+
+    getDocumentSymbolsWithCache(system: NodeSystem, file: Path): List[DocumentSymbol] {
+        self.fileSymbolsCache.get(file.absolute()).{
+            | Some(symbols) => 
+                //Log.trace("HIT symbols: " + file)
+                symbols
+            | None => 
+                //Log.trace("MISS symbols: " + file)
+                let symbols = self.getDocumentSymbols(system, file)
+                self.fileSymbolsCache = self.fileSymbolsCache.add(file.absolute(), symbols)
+                symbols
+        }
+    }
+
+    handleWorkspaceSymbol(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+        let js = system.js()
+        let query = parameters.grab("query").grabString()
+        let files = self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(self.rootPath.grab())}
+        let symbols = files.flatMap {file => 
+            let documentSymbols = self.getDocumentSymbolsWithCache(system, file)
+            let workspaceSymbols = documentSymbols.flatMap {SymbolHandler.documentToWorkspaceSymbols(_, None)}
+            if(query == "") {
+                workspaceSymbols.filter {_.kind == 5} // Class
+            } else {
+                workspaceSymbols.filter {SymbolHandler.symbolFilter(_, query)}
+            }
+        }
+        let limitedSymbols = symbols.sortBy {_.name.size()}.takeFirst(100)
+        let jsSymbols = limitedSymbols.map {SymbolHandler.workspaceSymbolToLsp(js, self.rootPath.grab(), _)}
+        Result(js.array(jsSymbols).toJson())        
+    }
+    
+    handleDidChange(system: NodeSystem, parameters: Map[String, JsValue]): Unit {
+        let js = system.js()
+        let uri = parameters.grab("textDocument").get("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        self.responseCache = Map.empty()
+        self.fileSymbolsCache = self.fileSymbolsCache.remove(path.absolute())
+        let contentChanges = parameters.grab("contentChanges").grabArray()
+        if(contentChanges.size() != 1) {throw(LanguageServerException("Expected a single element in contentChanges"))} else:
+        let contentChange = contentChanges.grab(0)
+        if(!contentChange.get("range").isNullOrUndefined()) {throw(LanguageServerException("Expected a complete contentChange"))} else:
+        let content = contentChange.get("text").grabString()
+        self.virtualFiles = self.virtualFiles.add(path.absolute(), content)
+    }
+
+    handleDidClose(system: NodeSystem, parameters: Map[String, JsValue]): Unit {
+        let js = system.js()
+        let uri = parameters.grab("textDocument").get("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        self.virtualFiles = self.virtualFiles.remove(path.absolute())
+    }
+
+    handleHover(system: NodeSystem, targetAt: Location, goToDefinition: Bool): ResultOrError {
+        let lspHook = LspHook.make(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+        try {
+            Builder.check(system, self.fireflyPath, system.path(targetAt.file), self.virtualFiles, lspHook, True)
+        } catch {| CompileError(at, message), error =>
+            Log.trace("handleHover check error: " + message)
+        } grab()
+        let o = if(goToDefinition) {
+            HoverHandler.handleGoToDefinition(system, self, lspHook)
+        } else {
+            HoverHandler.handleHover(system, self, lspHook)
+        }
+        Result(o.toJson())
+    }
+
+    handleCompletion(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+        let location = self.findLocationFromParameters(system, parameters)
+        let token = self.findToken(system, location, insertToken = True)
+        let completionAt = Location(
+            file = location.file
+            line = token.startLine
+            column = token.startColumn
+        )
+        Log.show(token.followedByLeftBracket)
+        let lspHook = LspHook.make(at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False)
+        try {
+            Builder.check(system, self.fireflyPath, system.path(completionAt.file), self.virtualFiles, lspHook, True)
+        } catch {| CompileError(at, message), error =>
+            Log.trace("handleCompletion check error: " + message)
+        } grab()
+        let o = CompletionHandler.handleCompletion(system, lspHook, completionAt.column == 1, token.followedByLeftBracket)
+        Result(o.toJson())
+    }
+
+    handleSignatureHelp(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+        let cursorAt = self.findLocationFromParameters(system, parameters)
+        let lspHook = LspHook.make(at = Some(cursorAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+        try {
+            let code = self.virtualFiles.get(cursorAt.file).else {system.path(cursorAt.file).readText()}
+            let tokens = Tokenizer.tokenize(cursorAt.file, code, None, True)
+            let parser = Parser.make(PackagePair("script", "script"), cursorAt.file, tokens, False, lspHook)
+            parser.parseModuleWithPackageInfo()
+            Unit // Think of a way to avoid writing this
+        } catch {| CompileError(at, message), error =>
+            Log.trace("handleSignatureHelp check error: " + message)
+        } grab()
+        let o = lspHook.results().collectFirst {
+            | ParseArgumentHook h {parameters.get("context") | Some(context)} {
+                context.get("activeSignatureHelp") | help
+            } {!help.isNullOrUndefined() && help.hasOwn("signatures")} {
+                help.get("signatures").get(0) | activeSignature
+            } {!activeSignature.isNullOrUndefined()} {
+                activeSignature.get("parameters").grabArray().last() | Some(fakeParameter)
+            } {
+                fakeParameter.get("label").grabString() == "/* Call " + h.callAt.show() + " */"
+            } => 
+                Some(SignatureHelpHandler.pickActiveParameter(help, h.argumentIndex, h.parameterName))
+            | ParseArgumentHook h => 
+                let callLspHook = LspHook.make(at = Some(h.callAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+                try {
+                    Builder.check(system, self.fireflyPath, system.path(cursorAt.file), self.virtualFiles, callLspHook, True)
+                } catch {| CompileError(at, message), error =>
+                    Log.trace("handleSignatureHelp check 2 error: " + message)
+                } grab()
+                let help = SignatureHelpHandler.handleSignatureHelp(system, callLspHook)
+                Some(SignatureHelpHandler.pickActiveParameter(help, h.argumentIndex, h.parameterName))
+            | _ => 
+                None
+        }
+        Result((o.else {system.js().null()}).toJson())
+    }
+
+    handleReferences(system: NodeSystem, targetAt: Location, local: Bool): ResultOrError {
+        let tokens = self.findReferences(system, targetAt, local)
+        let js = system.js()
+        let o = tokens.{
+            | None => js.null()
+            | Some(tokens) =>
+                let lspTokens = tokens.map {self.tokenLocationToLspLocation(system, _)}
+                js.array(lspTokens)
+        }
+        Result(o.toJson())
+    }
+
+    handleRename(system: NodeSystem, parameters: Map[String, JsValue]): ResultOrError {
+        let newName = parameters.grab("newName").grabString()
+        let targetAt = self.findTokenFromParameters(system, parameters)
+        let tokens = self.findReferences(system, targetAt, False)
+        let js = system.js()
+        tokens.{
+            | None => Error(-32602, "Token definition not found") // InvalidParams
+            | Some([]) => Result(js.null().toJson())
+            | Some([first, ..._] @ tokens) =>
+                let oldName = first.raw
+                Log.trace("Rename '" + oldName + "' to '" + newName + "'")
+
+                // TODO findReferences returns some bad tokens
+                let goodTokens = tokens.filter {_.raw == oldName}
+                let badTokens = tokens.filter {_.raw != oldName}
+                badTokens.each {t => Log.trace("Rename bad token: " + Show.show(t))}
+
+                let byFile = goodTokens.map {t => Pair(t.file, t)}.group()
+                let allChanges = byFile.toList().foldLeft(js.object(), {| o, Pair(file, fileTokens) =>
+                    let uri = system.path(file).url()
+                    let fileChanges = fileTokens.map {tokenLocation =>
+                        js.object()
+                            .with("range", self.tokenLocationToLspRange(js, tokenLocation))
+                            .with("newText", newName)
+                    }
+                    o.with(uri, js.array(fileChanges))
+                })
+                let o = js.object().with("changes", allChanges)
+                Result(o.toJson())
+        }
+    }
+
+    findReferences(system: NodeSystem, targetAt: Location, local: Bool): Option[List[TokenLocation]] {
+        let temporaryLspHook = LspHook.make(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+        try {
+            Builder.check(system, self.fireflyPath, system.path(targetAt.file), self.virtualFiles, temporaryLspHook, True)
+        } catch {| CompileError(at, message), error =>
+            Log.trace("findReferences first check error: " + message)
+        } grab()
+
+        //Log.trace("defined at hooks: " + Show.show(temporaryLspHook.results().map(LspHook.showHook)))
+        let definedAtList = temporaryLspHook.results().collect {
+            | ResolveSymbolHook h => Some(h.symbol.definedAt)
+            | ResolveVariantFieldHook h => Some(h.symbol.definedAt)
+            | ResolveTypeHook h => Some(h.symbol.definedAt)
+            | ResolveConstraintHook h => Some(h.symbol.definedAt)
+            | ResolveSignatureHook h {!h.isInstanceMethod} => Some(h.signature.at)
+            | InferParameterHook h => Some(h.parameter.at)
+            | InferArgumentHook h {h.arguments.dropFirst(h.argumentIndex).first() | Some(a)} {a.name | Some(n)} => 
+                h.parameters.find {_.name == n}.map {_.at}
+            | InferLookupHook h => Some(h.symbol.value.definedAt)
+            | InferPatternHook h {h.pattern | PVariantAs p} => Some(p.variableAt)
+            | InferPatternHook h {h.pattern | PVariable p} => Some(p.at)
+            | InferPatternHook h {h.pattern | PAlias p} => Some(p.at)
+            | _ => None
+        }.filter {at => !at.file.endsWith(">")}
+            
+        //Log.trace("definedAtList: " + Show.show(definedAtList))
+
+        let js = system.js()
+        definedAtList.first().{
+            | Some(definedAt) =>
+                //Log.trace("handleReferences definedAt: " + Show.show(definedAt))
+                let lspHook = LspHook.make(at = None, definedAt = Some(definedAt), insertIdentifier = False, trackSymbols = False)
+                try {
+                    let path = if(local) {system.path(targetAt.file)} else {self.rootPath.grab()}
+                    Builder.check(system, self.fireflyPath, path, self.virtualFiles, lspHook, True)
+                } catch {| CompileError(at, message), error =>
+                    // TODO: This skips checking all the other files
+                    Log.trace("findReferences second check error: " + message)
+                } grab()
+
+                let referencesResult = lspHook.results().collect {
+                    | ResolveSymbolHook h => Some(h.symbol.usageAt)
+                    | ResolveVariantFieldHook h => Some(h.symbol.usageAt)
+                    | ResolveTypeHook h => Some(h.symbol.usageAt)
+                    | ResolveConstraintHook h => Some(h.symbol.usageAt)
+                    | ResolveSignatureHook h => Some(h.signature.at)
+                    | InferParameterHook h => Some(h.parameter.at)
+                    | InferArgumentHook h {h.arguments.dropFirst(h.argumentIndex).first() | Some(a)} {a.name | Some(n)} => 
+                        h.parameters.find {_.name == n}.map {_ => a.at}
+                    | InferLookupHook h => Some(h.symbol.value.usageAt)
+                    | _ => None
+                }.filter {at => !at.file.endsWith(">")}
+
+                //Log.trace("referencesResult: " + Show.show(referencesResult))
+
+                let clientLocations = referencesResult.addAll([definedAt]).distinct().filter {
+                    !local || _.file == targetAt.file
+                }.map {at =>
+                    self.findToken(system, at)
+                }
+                let sorted = clientLocations.sortBy {c => Location(c.file, c.startLine, c.startColumn)}
+                Some(sorted)
+            | None =>
+                None
+        }
+    }
+
+    makeNotificationMessage(js: JsSystem, method: String, params: JsValue): JsValue {
+        js.object()
+            .with("jsonrpc", "2.0")
+            .with("method", method)
+            .with("params", params)
+    }
+
+    findToken(system: NodeSystem, at: Location, insertToken: Bool = False): TokenLocation {
+        let fallback = TokenLocation(
+            file = at.file
+            startLine = at.line
+            startColumn = at.column
+            endLine = at.line
+            endColumn = at.column + 1
+            raw = ""
+            followedByLeftBracket = True
+        )
+        try {
+            let code = self.virtualFiles.get(at.file).else {system.path(at.file).readText()}
+            let tokens = Tokenizer.tokenize(at.file, code, Some(at).filter {_ => insertToken}, True)
+            let token = tokens.toStream().find {token =>
+                at.line >= token.startLine && at.line <= token.stopLine && (
+                    (at.line > token.startLine || at.column >= 1 + token.startOffset - token.startLineOffset) &&
+                    (at.line < token.stopLine || at.column < 1 + token.stopOffset - token.stopLineOffset || (
+                        (token.kind == LLower || token.kind == LUpper) &&
+                        at.column == 1 + token.stopOffset - token.stopLineOffset
+                    ))
+                )
+            }
+            token.map {t => 
+                function leftBracketAt(i: Int): Bool {
+                    i >= 0 && i < code.size() && 
+                    (code.grab(i) == '(' || code.grab(i) == '[' || code.grab(i) == '{')
+                }
+                let followedByLeftBracket = 
+                    leftBracketAt(t.startOffset) || 
+                    leftBracketAt(t.stopOffset) || 
+                    leftBracketAt(t.stopOffset + 1)
+                TokenLocation(
+                    file = t.file
+                    startLine = t.startLine
+                    startColumn = 1 + t.startOffset - t.startLineOffset
+                    endLine = t.stopLine
+                    endColumn = 1 + t.stopOffset - t.stopLineOffset
+                    raw = t.raw()
+                    followedByLeftBracket = followedByLeftBracket
+                )
+            }.else {fallback}
+        } catchAny {_ =>
+            fallback
+        } grab()
+    }
+
+    findTokenFromParameters(system: NodeSystem, parameters: Map[String, JsValue]): Location {
+        let location = self.findLocationFromParameters(system, parameters)
+        let token = self.findToken(system, location)
+        Location(
+            file = location.file
+            line = token.startLine
+            column = token.startColumn
+        )
+    }
+
+    findLocationFromParameters(system: NodeSystem, parameters: Map[String, JsValue]): Location {
+        let uri = parameters.grab("textDocument").get("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        let line = parameters.grab("position").get("line").grabInt() + 1
+        let column = parameters.grab("position").get("character").grabInt() + 1
+        Location(path.absolute(), line, column)
+    }
+
+    tokenLocationToLspLocation(system: NodeSystem, tokenLocation: TokenLocation): JsValue {
+        let js = system.js()
+        js.object()
+            .with("uri", system.path(tokenLocation.file).url())
+            .with("range", self.tokenLocationToLspRange(js, tokenLocation))
+    }
+
+    tokenLocationToLspRange(js: JsSystem, tokenLocation: TokenLocation): JsValue {
+        js.object()
+            .with("start", js.object()
+                .with("line", tokenLocation.startLine - 1)
+                .with("character", tokenLocation.startColumn - 1)
+            )
+            .with("end", js.object()
+                .with("line", tokenLocation.endLine - 1)
+                .with("character", tokenLocation.endColumn - 1)
+            )
+    }
+    
+    printTime[R](task: Task, label: String, body: () => R): R {
+        let start = task.elapsed()
+        let result = body()
+        let stop = task.elapsed()
+        let duration = ("" + (stop.seconds - start.seconds)).slice(0, 5)
+        Log.trace(label + ": " + duration + "s")
+        result
+    }
+
+}

package/lsp/HoverHandler.ff

@@ -0,0 +1,82 @@
+import LspHook from ff:compiler
+import Unification from ff:compiler
+import Environment from ff:compiler
+import Syntax from ff:compiler
+import Handler
+
+handleGoToDefinition(system: NodeSystem, handler: Handler, lspHook: LspHook): JsValue {
+    let js = system.js()
+    let definedAt = lspHook.results().collect {
+        | ResolveSymbolHook h => Some(h.symbol.definedAt)
+        | ResolveTypeHook h => Some(h.symbol.definedAt)
+        | ResolveConstraintHook h => Some(h.symbol.definedAt)
+        | InferLookupHook h => Some(h.symbol.value.definedAt)
+        | InferParameterHook h => Some(h.parameter.at)
+        | InferArgumentHook h {h.arguments.dropFirst(h.argumentIndex).first() | Some(a)} =>
+            a.name.flatMap {name =>
+                h.parameters.find {_.name == name}.map {p =>
+                    p.at
+                }
+            }
+        | InferRecordFieldHook h {h.unification.substitute(h.recordType) | TConstructor(_, n, ts)} => 
+            let fieldNames = n.split('$').toList().dropFirst(1)
+            fieldNames.zip(ts).collectFirst {| Pair(name, t) =>
+                if(h.fieldName == name) {
+                    h.unification.substitute(t).at // TODO: This points to the field type rather than the field name
+                }
+            }
+        | _ => None
+    }
+    Log.trace("handleGoToDefinition definedAt: " + Show.show(definedAt))
+    definedAt.first().map {at =>
+        let token = handler.findToken(system, at)
+        handler.tokenLocationToLspLocation(system, token)
+    }.else {js.null()}
+}
+
+handleHover(system: NodeSystem, handler: Handler, lspHook: LspHook): JsValue {
+    let js = system.js()
+    let typeAndEffect = lspHook.results().collectFirst {
+        | InferLookupHook h {h.instantiated.value | Some(instantiated)} => 
+            let t = h.unification.substitute(instantiated.scheme.signature.returnType)
+            let q = h.unification.substitute(instantiated.scheme.signature.effect)
+            Some(Pair(t, q))
+        | InferPatternHook h =>
+            let t = h.unification.substitute(h.expected)
+            let noEffect = TConstructor(h.pattern.at, "ff:core/Nothing.Nothing", [])
+            Some(Pair(t, noEffect))
+        | InferTermHook h {h.term | ELet e} =>
+            let t = h.unification.substitute(e.valueType)
+            let noEffect = TConstructor(e.at, "ff:core/Nothing.Nothing", [])
+            Some(Pair(t, noEffect))
+        | InferArgumentHook h {h.arguments.dropFirst(h.argumentIndex).first() | Some(a)} =>
+            let noEffect = TConstructor(h.callAt, "ff:core/Nothing.Nothing", [])
+            a.name.flatMap {name =>
+                h.parameters.find {_.name == name}.map {p =>
+                    Pair(h.unification.substitute(p.valueType), noEffect)
+                }
+            }
+        | InferRecordFieldHook h {h.unification.substitute(h.recordType) | TConstructor(_, n, ts)} => 
+            let fieldNames = n.split('$').toList().dropFirst(1)
+            fieldNames.zip(ts).collectFirst {| Pair(name, t) =>
+                if(h.fieldName == name) {
+                    let noEffect = TConstructor(t.at, "ff:core/Nothing.Nothing", [])
+                    let t2 = h.unification.substitute(t)
+                    Pair(h.unification.substitute(t), noEffect)
+                }
+            }
+        | _ => 
+            None
+    }
+    typeAndEffect.map {| Pair(t, q) =>
+        let extra = q.{
+            | TConstructor(_, "Q$", _) => "*This call may be asynchronous.*"
+            | _ => ""
+        }
+        js.object().with("contents", 
+            js.object()
+                .with("kind", "markdown")
+                .with("value", "```\n" + t.show([]) + "\n```\n" + extra)
+        )
+    }.else {js.null()}
+}