firefly-compiler 0.5.35 → 0.5.37

package/lsp/Handler.ff

@@ -1,714 +1,714 @@
-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 ModuleCache from ff:compiler
-import DependencyLock 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[TokenRequestCacheKey, ResultOrError]
-    mutable fileSymbolsCache: Map[String, List[DocumentSymbol]]
-    moduleCache: ModuleCache
-    dependencyLock: DependencyLock
-)
-
-data TokenRequestCacheKey(
-    method: String
-    targetAt: Location
-    includeDeclaration: Bool
-)
-
-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
-)
-
-data Definition(at: Location, name: String, local: Bool)
-
-
-extend self: Handler {
-
-    handleNotification(system: NodeSystem, method: String, parameters: Map[String, Json], version: Int): List[Pair[String, Json]] {
-        method.{
-            | "initialized" =>
-                []
-            | "textDocument/didOpen" => 
-                self.handleDidOpen(system, parameters)
-                []
-            | "textDocument/didChange" => 
-                self.handleDidChange(system, parameters)
-                let diagnostics = self.handleFocusDiagnostic(system, parameters, version)
-                [Pair("textDocument/publishDiagnostics", diagnostics)]
-            | "textDocument/didClose" => 
-                self.handleDidClose(system, parameters)
-                let diagnostics = self.handleFocusDiagnostic(system, parameters, version)
-                [Pair("textDocument/publishDiagnostics", diagnostics)]
-            | "custom/focusDocument" => 
-                let diagnostics = self.handleFocusDiagnostic(system, parameters, version)
-                [Pair("textDocument/publishDiagnostics", diagnostics)]
-            | "workspace/didRenameFiles" =>
-                let diagnostics = self.handleClearDiagnostic(system, parameters)
-                diagnostics.map {Pair("textDocument/publishDiagnostics", _)}
-            | "workspace/didDeleteFiles" =>
-                let diagnostics = self.handleClearDiagnostic(system, parameters)
-                diagnostics.map {Pair("textDocument/publishDiagnostics", _)}
-            | "workspace/didChangeWatchedFiles" =>
-                self.handleDidChangeWatched(system, parameters)
-            | "exit" => 
-                system.exit(0)
-            | _ =>
-                []
-        }
-    }
-
-    handleRequest(system: NodeSystem, method: String, parameters: Map[String, Json], version: Int): 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, version)
-            | "textDocument/signatureHelp" => self.handleSignatureHelp(system, parameters, version)
-            | "textDocument/hover" => 
-                self.handleTokenRequestWithCache(system, method, parameters) {key => 
-                    self.handleHover(system, key.targetAt, goToDefinition = False, version)
-                }
-            | "textDocument/definition" => 
-                self.handleTokenRequestWithCache(system, method, parameters) {key => 
-                    self.handleHover(system, key.targetAt, goToDefinition = True, version)
-                }
-            | "textDocument/references" => 
-                self.handleTokenRequestWithCache(system, method, parameters) {key => 
-                    self.handleReferences(system, key.targetAt, key.includeDeclaration, local = False, version)
-                }
-            | "textDocument/rename" => self.handleRename(system, parameters, version)
-            | "textDocument/documentHighlight" => 
-                self.handleTokenRequestWithCache(system, method, parameters) {key => 
-                    self.handleReferences(system, key.targetAt, includeDeclaration = True, local = True, version)
-                }
-            | "workspace/symbol" => 
-                self.printTime(system.mainTask(), "handleWorkspaceSymbol") {
-                    self.handleWorkspaceSymbol(system, parameters)
-                }
-            | "shutdown" => Result(Json.null().write())
-            | _ => self.handleUnsupported()
-        }
-    }
-
-    handleTokenRequestWithCache(
-        system: NodeSystem
-        method: String
-        parameters: Map[String, Json]
-        handle: TokenRequestCacheKey => ResultOrError
-    ): ResultOrError {
-        let targetAt = self.findTokenFromParameters(system, parameters)
-        let includeDeclaration = parameters.get("context").{
-            | Some(context) {context.field("includeDeclaration") | includeDeclaration} {includeDeclaration.getBool() | Some(b)} => b
-            | _ => True
-        }        
-        let cacheKey = TokenRequestCacheKey(method, targetAt, includeDeclaration)
-        self.responseCache.get(cacheKey).{
-            | Some(hit) => hit
-            | None => 
-                let result = handle(cacheKey)
-                self.responseCache = self.responseCache.add(cacheKey, result)
-                result
-        }
-    }
-
-    handleUnsupported(): ResultOrError {
-        Error(1234, "Unsupported method")
-    }
-
-    handleInitialize(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
-        self.rootPath = parameters.grab("rootUri").getString().map {system.pathFromUrl(_)}
-
-        let anyFireflyFile = Json.object()
-            .with("filters", [
-                Json.object()
-                    .with("pattern", Json.object()
-                        .with("glob", "**/*.ff")
-                        .with("matches", "file")
-                    )
-            ])
-
-        let o = Json.object()
-            .with("capabilities", Json.object()
-                .with("textDocumentSync", Json.object()
-                    .with("openClose", True)
-                    .with("change", 1 /* TextDocumentSyncKind.Full */)
-                )
-                .with("hoverProvider", True)
-                .with("definitionProvider", True)
-                .with("documentHighlightProvider", True)
-                /*.with("diagnosticProvider", Json.object()
-                    .with("interFileDependencies", False)
-                    .with("workspaceDiagnostics", False)
-                )*/
-                .with("documentSymbolProvider", True)
-                .with("completionProvider", Json.object()
-                    .with("triggerCharacters", [".", " ", "("])
-                    .with("allCommitCharacters", [";"])
-                )
-                .with("signatureHelpProvider", Json.object()
-                    .with("triggerCharacters", ["("])
-                    .with("retriggerCharacters", [","])
-                )
-                .with("referencesProvider", True)
-                .with("workspaceSymbolProvider", True)
-                .with("workspace", Json.object()
-                    .with("fileOperations", Json.object()
-                        .with("didRename", anyFireflyFile)
-                        .with("didDelete", anyFireflyFile)
-                    )
-                )
-                /*
-                    .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", Json.object()
-                .with("name", "Firefly Language Server")
-                .with("version", "0.0.0")
-            )
-        Result(o.write())
-    }
-
-    /*handleDiagnostic(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
-        let js = system.js()
-        let uri = parameters.grab("textDocument").field("uri").grabString()
-        let path = system.pathFromUrl(uri)
-        let fireflyPath = system.path(".")
-        let errors = self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, LspHook.disabled(), True)
-        let diagnostics = errors.map {| CompileError(at, message) => 
-            let tokenLocation = self.findToken(system, at)
-            Json.object()
-                .with("range", self.tokenLocationToLspRange(tokenLocation))
-                .with("severity", 1)
-                .with("message", message)
-        }
-        let o = Json.object()
-            .with("kind", "full")
-            .with("items", diagnostics)
-        Result(o.write())
-    }*/
-
-    handleFocusDiagnostic(system: NodeSystem, parameters: Map[String, Json], version: Int): Json {
-        let js = system.js()
-        let uri = parameters.grab("textDocument").field("uri").grabString()
-        let path = system.pathFromUrl(uri)
-        let fireflyPath = system.path(".")
-        let errors = self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, LspHook.disabled(), True)
-        let diagnostics = errors.filter {_.at.file == path.absolute()}.map {| CompileError(at, message) => 
-            let tokenLocation = self.findToken(system, at)
-            Json.object()
-                .with("range", self.tokenLocationToLspRange(tokenLocation))
-                .with("severity", 1)
-                .with("message", message)
-        }
-        Json.object()
-            .with("uri", uri)
-            .with("version", parameters.grab("textDocument").field("version"))
-            .with("diagnostics", diagnostics)
-    }
-    
-    handleClearDiagnostic(system: NodeSystem, parameters: Map[String, Json]): List[Json] {
-        let js = system.js()
-        let files = parameters.grab("files").grabArray()
-        files.map {file =>
-            let uri = file.getField("uri").else {file.grabField("oldUri")}
-            Json.object()
-                .with("uri", uri)
-                .with("diagnostics", Json.array([]))
-        }
-    }
-    
-    handleDocumentSymbol(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
-        let uri = parameters.grab("textDocument").field("uri").grabString()
-        let path = system.pathFromUrl(uri)
-        let symbols = self.getDocumentSymbolsWithCache(system, path)
-        let lspSymbols = symbols.map {SymbolHandler.documentSymbolToLsp(_)}
-        Result(Json.array(lspSymbols).write())
-    }
-
-    getDocumentSymbols(system: NodeSystem, path: Path): List[DocumentSymbol] {
-        try {
-            let lspHook = LspHook.new(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.new(PackagePair("script", "script"), path.absolute(), tokens, False, lspHook)
-            parser.parseModuleWithPackageInfo()
-            SymbolHandler.readAllSymbols(lspHook.results())
-        } tryCatch {| CompileError(at, message), error =>
-            Log.trace("handleDocumentSymbol parse error: " + message)
-            []
-        } catch {| ReadSymbolsError e, _ => 
-            Log.trace("handleDocumentSymbol ReadSymbolsError")
-            []
-        }     
-    }
-
-    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, Json]): ResultOrError {
-        self.rootPath.or {Error(-32803 /*Request Failed*/, "Open a folder to enable workspace symbols")}: rootPath =>
-        let files = if(rootPath.isFile()) {
-            [rootPath]
-        } else {
-            self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(rootPath, None, Set.new())}
-        }
-        let root = if(rootPath.isFile()) {rootPath.parent().grab()} else {rootPath}
-        let query = parameters.grab("query").grabString()
-        let symbols = files.flatMap {file => 
-            let documentSymbols = self.getDocumentSymbolsWithCache(system, file)
-            let workspaceSymbols = documentSymbols.flatMap {SymbolHandler.documentToWorkspaceSymbols(_, None)}
-            if(query == "") {
-                workspaceSymbols.filter {_.kind == SType}
-            } else {
-                workspaceSymbols.filter {SymbolHandler.symbolFilter(_, query)}
-            }
-        }
-        let limitedSymbols = symbols.sortBy {_.name.size()}.takeFirst(100)
-        let jsSymbols = limitedSymbols.map {SymbolHandler.workspaceSymbolToLsp(root, _)}
-        Result(Json.array(jsSymbols).write())
-    }
-    
-    handleDidChangeWatched(system: NodeSystem, parameters: Map[String, Json]): List[Pair[String, Json]] {
-        let creates = parameters.grab("changes").grabArray().filter {_.field("type").grabInt() == 1}
-        let changes = parameters.grab("changes").grabArray().filter {_.field("type").grabInt() == 2}
-        let deletes = parameters.grab("changes").grabArray().filter {_.field("type").grabInt() == 3}
-        creates.map {_.field("uri").grabString()}.each {self.moduleCache.invalidate(system.pathFromUrl(_).absolute())}
-        changes.map {_.field("uri").grabString()}.each {self.moduleCache.invalidate(system.pathFromUrl(_).absolute())}
-        deletes.map {_.field("uri").grabString()}.each {self.moduleCache.invalidate(system.pathFromUrl(_).absolute())}
-        let diagnostics = self.handleClearDiagnostic(system, [Pair("files", Json.array(deletes))].toMap())
-        diagnostics.map {Pair("textDocument/publishDiagnostics", _)}
-    }
-    
-    handleDidOpen(system: NodeSystem, parameters: Map[String, Json]): Unit {
-        let uri = parameters.grab("textDocument").field("uri").grabString()
-        let path = system.pathFromUrl(uri)
-        if(self.rootPath.isEmpty()) {
-            Log.trace("Using file as rootPath: " + path.absolute())
-            self.rootPath = Some(path)
-        }
-    }
-
-    handleDidChange(system: NodeSystem, parameters: Map[String, Json]): Unit {
-        let uri = parameters.grab("textDocument").field("uri").grabString()
-        let path = system.pathFromUrl(uri)
-        self.responseCache = Map.new()
-        self.fileSymbolsCache = self.fileSymbolsCache.remove(path.absolute())
-        self.moduleCache.invalidate(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.field("range").isNull()) {throw(LanguageServerException("Expected a complete contentChange"))} else:
-        let content = contentChange.field("text").grabString()
-        self.virtualFiles = self.virtualFiles.add(path.absolute(), content)
-    }
-
-    handleDidClose(system: NodeSystem, parameters: Map[String, Json]): Unit {
-        let uri = parameters.grab("textDocument").field("uri").grabString()
-        let path = system.pathFromUrl(uri)
-        self.virtualFiles = self.virtualFiles.remove(path.absolute())
-    }
-
-    handleHover(system: NodeSystem, targetAt: Location, goToDefinition: Bool, version: Int): ResultOrError {
-        let lspHook = LspHook.new(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
-        let path = system.path(targetAt.file)
-        let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
-        errors.each {| CompileError(at, message) => 
-            Log.trace("handleHover check error: " + message)
-        }
-        let o = if(goToDefinition) {
-            HoverHandler.handleGoToDefinition(system, self, lspHook)
-        } else {
-            HoverHandler.handleHover(system, self, lspHook)
-        }
-        Result(o.write())
-    }
-
-    handleCompletion(system: NodeSystem, parameters: Map[String, Json], version: Int): 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
-        )
-        let lspHook = LspHook.new(at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False)
-        let path = system.path(completionAt.file)
-        let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
-        errors.each {| CompileError(at, message) => 
-            Log.trace("handleCompletion check error: " + message)
-        }        
-        let o = CompletionHandler.handleCompletion(lspHook, completionAt.column == 1, token.followedByLeftBracket)
-        Result(o.write())
-    }
-
-    handleSignatureHelp(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
-        let cursorAt = self.findLocationFromParameters(system, parameters)
-        let lspHook = LspHook.new(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.new(PackagePair("script", "script"), cursorAt.file, tokens, False, lspHook)
-            parser.parseModuleWithPackageInfo()
-        } catch {| CompileError(at, message), error =>
-            Log.trace("handleSignatureHelp check error: " + message)
-        }
-        let o = lspHook.results().collectFirst {
-            | ParseArgumentHook h {parameters.get("context") | Some(context)} {
-                context.field("activeSignatureHelp") | help
-            } {!help.isNull() && help.hasField("signatures")} {
-                help.field("signatures").index(0) | activeSignature
-            } {!activeSignature.isNull()} {
-                activeSignature.field("parameters").grabArray().last() | Some(fakeParameter)
-            } {
-                fakeParameter.field("label").grabString() == "/* Call " + h.callAt.show() + " */"
-            } => 
-                Some(SignatureHelpHandler.pickActiveParameter(help, h.argumentIndex, h.parameterName))
-            | ParseArgumentHook h => 
-                let callLspHook = LspHook.new(at = Some(h.callAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
-                let path = system.path(cursorAt.file)
-                let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, callLspHook, True)
-                errors.each {| CompileError(at, message) => 
-                    Log.trace("handleSignatureHelp check 2 error: " + message)
-                }        
-                let help = SignatureHelpHandler.handleSignatureHelp(system, callLspHook)
-                if(!help.isNull()) {
-                    SignatureHelpHandler.pickActiveParameter(help, h.argumentIndex, h.parameterName)
-                }
-            | _ => 
-                None
-        }
-        Result((o.else {Json.null()}).write())
-    }
-
-    handleReferences(system: NodeSystem, targetAt: Location, includeDeclaration: Bool, local: Bool, version: Int): ResultOrError {
-        let tokens = self.findReferences(system, targetAt, local, includeDeclaration, version)
-        let o = tokens.{
-            | None => Json.null()
-            | Some(tokens) =>
-                let lspTokens = tokens.map {self.tokenLocationToLspLocation(system, _)}
-                Json.array(lspTokens)
-        }
-        Result(o.write())
-    }
-
-    handleRename(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
-        let newName = parameters.grab("newName").grabString()
-        let targetAt = self.findTokenFromParameters(system, parameters)
-        let tokens = self.findReferences(system, targetAt, local = False, includeDeclaration = True, version = version)
-        tokens.{
-            | None => Error(-32602, "Token definition not found") // InvalidParams
-            | Some([]) => Result(Json.null().write())
-            | 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(Json.object(), {| o, Pair(file, fileTokens) =>
-                    let uri = system.path(file).url()
-                    let fileChanges = fileTokens.map {tokenLocation =>
-                        Json.object()
-                            .with("range", self.tokenLocationToLspRange(tokenLocation))
-                            .with("newText", newName)
-                    }
-                    o.with(uri, fileChanges)
-                })
-                let o = Json.object().with("changes", allChanges)
-                Result(o.write())
-        }
-    }
-
-    findReferences(
-        system: NodeSystem
-        targetAt: Location
-        local: Bool
-        includeDeclaration: Bool
-        version: Int
-    ): Option[List[TokenLocation]] {
-        let temporaryLspHook = LspHook.new(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
-        let path = system.path(targetAt.file)
-        let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, temporaryLspHook, True)
-        errors.each {| CompileError(at, message) => 
-            Log.trace("findReferences first check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
-        }  
-                
-        //Log.trace("defined at hooks: " + Show.show(temporaryLspHook.results().map(LspHook.showHook)))
-        let definedAtList = temporaryLspHook.results().collect {
-            | ResolveSymbolHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, local = !h.topLevel))
-            | ResolveVariantFieldHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, False))
-            | ResolveTypeHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, False))
-            | ResolveConstraintHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, False))
-            | ResolveSignatureHook h {!h.isInstanceMethod} => Some(Definition(h.signature.at, h.signature.name, local = !h.topLevel))
-            | InferParameterHook h => Some(Definition(h.parameter.at, h.parameter.name, False))
-            | InferArgumentHook h {h.arguments.dropFirst(h.argumentIndex).first() | Some(a)} {a.name | Some(n)} => 
-                h.parameters.find {_.name == n}.map {Definition(_.at, n, False)}
-            | InferLookupHook h => Some(Definition(h.symbol.value.definedAt, h.symbol.value.qualifiedName, False))
-            | InferPatternHook h {h.pattern | PVariantAs p} => Some(Definition(p.variableAt, p.name, False))
-            | InferPatternHook h {h.pattern | PVariable p} => p.name.map {Definition(p.at, _, False)}
-            | InferPatternHook h {h.pattern | PAlias p} => Some(Definition(p.at, p.variable, False))
-            | InferRecordFieldHook h {h.unification.substitute(h.recordType) | TConstructor(_, n, ts)} =>
-                let fieldNames = n.split('$').dropFirst(1)
-                let fieldDefinedAt = fieldNames.zip(ts).collectFirst {| Pair(name, t) =>
-                    if(name == h.fieldName) {t.at}
-                }
-                fieldDefinedAt.map {Definition(_, h.fieldName, False)}
-            | h => None
-        }.filter {pair => !pair.at.file.endsWith(">")}
-            
-        function unqualify(qualifiedName: String): String {
-            qualifiedName.split('.').grabLast().split('_').grabLast()
-        }
-
-        function extractModuleName(qualifiedName: String): String {
-            qualifiedName.split('/').grabLast().takeWhile {c => c != '.' || c == '_'}
-        }
-
-        function extractPackagePair(qualifiedName: String): PackagePair {
-            let group = qualifiedName.split(':').grabFirst()
-            let name = qualifiedName.split(':').grabLast().takeWhile {_ != '/'}
-            PackagePair(group, name)
-        }
-
-        definedAtList.first().{
-            | Some(definition) =>
-                let lspHook = LspHook.new(at = None, definedAt = Some(definition.at), insertIdentifier = False, trackSymbols = False)
-                let localCheck = local || definition.local
-                let path = if(localCheck) {system.path(targetAt.file)} else {self.rootPath.else {system.path(targetAt.file)}}
-                let mustContain = Some(definition.name).filter {_ => !localCheck}.map(unqualify)
-                Log.trace("findReferences definition: " + Show.show(definition))
-                mustContain.each {Log.trace("mustContain: " + _)}
-                
-                let skipFiles = if(definition.name.contains(":")) {
-                    let list = self.moduleCache.filesNotImporting(extractPackagePair(definition.name), extractModuleName(definition.name))
-                    list.toSet()
-                } else {
-                    self.moduleCache.parsedModules.get(definition.at.file).map {| Pair(module, _) =>
-                        let list = self.moduleCache.filesNotImporting(module.packagePair, module.file.dropLast(3))
-                        list.toSet()
-                    }.else {
-                        Log.trace("No skip list due to unqualified definition.name: " + definition.name)
-                        Set.new()
-                    }
-                }
-                let errors = self.check(system, self.fireflyPath, path, mustContain, skipFiles, self.virtualFiles, version, lspHook, True, False)
-                errors.each {| CompileError(at, message) => 
-                    Log.trace("findReferences second check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
-                }
-
-                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)
-                    | InferRecordFieldHook h => Some(h.usageAt)
-                    | _ => None
-                }.filter {at => 
-                    !at.file.endsWith(">") &&
-                    (includeDeclaration || at != definition.at)
-                }
-                
-                //referencesResult.each {Log.trace(Show.show(_))}
-
-                let clientLocations = referencesResult.addAll(
-                    if(includeDeclaration) {[definition.at]} else {[]}
-                ).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(method: String, params: Json): Json {
-        Json.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
-        }
-    }
-
-    findTokenFromParameters(system: NodeSystem, parameters: Map[String, Json]): 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, Json]): Location {
-        let uri = parameters.grab("textDocument").field("uri").grabString()
-        let path = system.pathFromUrl(uri)
-        let line = parameters.grab("position").field("line").grabInt() + 1
-        let column = parameters.grab("position").field("character").grabInt() + 1
-        Location(path.absolute(), line, column)
-    }
-
-    tokenLocationToLspLocation(system: NodeSystem, tokenLocation: TokenLocation): Json {
-        Json.object()
-            .with("uri", system.path(tokenLocation.file).url())
-            .with("range", self.tokenLocationToLspRange(tokenLocation))
-    }
-
-    tokenLocationToLspRange(tokenLocation: TokenLocation): Json {
-        Json.object()
-            .with("start", Json.object()
-                .with("line", tokenLocation.startLine - 1)
-                .with("character", tokenLocation.startColumn - 1)
-            )
-            .with("end", Json.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
-    }
-    
-    check(
-        system: NodeSystem
-        fireflyPath: Path
-        path: Path
-        mustContain: Option[String]
-        skipFiles: Set[String]
-        virtualFiles: Map[String, String]
-        newModuleCacheVersion: Int
-        lspHook: LspHook
-        infer: Bool
-        checkDependencies: Bool = True
-    ): List[CompileError] {
-        Builder.check(
-            system
-            fireflyPath
-            path
-            mustContain
-            skipFiles
-            virtualFiles
-            self.moduleCache
-            self.dependencyLock
-            newModuleCacheVersion
-            lspHook
-            infer
-            checkDependencies
-        )
-    }
-
-}
+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 ModuleCache from ff:compiler
+import DependencyLock 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[TokenRequestCacheKey, ResultOrError]
+    mutable fileSymbolsCache: Map[String, List[DocumentSymbol]]
+    moduleCache: ModuleCache
+    dependencyLock: DependencyLock
+)
+
+data TokenRequestCacheKey(
+    method: String
+    targetAt: Location
+    includeDeclaration: Bool
+)
+
+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
+)
+
+data Definition(at: Location, name: String, local: Bool)
+
+
+extend self: Handler {
+
+    handleNotification(system: NodeSystem, method: String, parameters: Map[String, Json], version: Int): List[Pair[String, Json]] {
+        method.{
+            | "initialized" =>
+                []
+            | "textDocument/didOpen" => 
+                self.handleDidOpen(system, parameters)
+                []
+            | "textDocument/didChange" => 
+                self.handleDidChange(system, parameters)
+                let diagnostics = self.handleFocusDiagnostic(system, parameters, version)
+                [Pair("textDocument/publishDiagnostics", diagnostics)]
+            | "textDocument/didClose" => 
+                self.handleDidClose(system, parameters)
+                let diagnostics = self.handleFocusDiagnostic(system, parameters, version)
+                [Pair("textDocument/publishDiagnostics", diagnostics)]
+            | "custom/focusDocument" => 
+                let diagnostics = self.handleFocusDiagnostic(system, parameters, version)
+                [Pair("textDocument/publishDiagnostics", diagnostics)]
+            | "workspace/didRenameFiles" =>
+                let diagnostics = self.handleClearDiagnostic(system, parameters)
+                diagnostics.map {Pair("textDocument/publishDiagnostics", _)}
+            | "workspace/didDeleteFiles" =>
+                let diagnostics = self.handleClearDiagnostic(system, parameters)
+                diagnostics.map {Pair("textDocument/publishDiagnostics", _)}
+            | "workspace/didChangeWatchedFiles" =>
+                self.handleDidChangeWatched(system, parameters)
+            | "exit" => 
+                system.exit(0)
+            | _ =>
+                []
+        }
+    }
+
+    handleRequest(system: NodeSystem, method: String, parameters: Map[String, Json], version: Int): 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, version)
+            | "textDocument/signatureHelp" => self.handleSignatureHelp(system, parameters, version)
+            | "textDocument/hover" => 
+                self.handleTokenRequestWithCache(system, method, parameters) {key => 
+                    self.handleHover(system, key.targetAt, goToDefinition = False, version)
+                }
+            | "textDocument/definition" => 
+                self.handleTokenRequestWithCache(system, method, parameters) {key => 
+                    self.handleHover(system, key.targetAt, goToDefinition = True, version)
+                }
+            | "textDocument/references" => 
+                self.handleTokenRequestWithCache(system, method, parameters) {key => 
+                    self.handleReferences(system, key.targetAt, key.includeDeclaration, local = False, version)
+                }
+            | "textDocument/rename" => self.handleRename(system, parameters, version)
+            | "textDocument/documentHighlight" => 
+                self.handleTokenRequestWithCache(system, method, parameters) {key => 
+                    self.handleReferences(system, key.targetAt, includeDeclaration = True, local = True, version)
+                }
+            | "workspace/symbol" => 
+                self.printTime(system.mainTask(), "handleWorkspaceSymbol") {
+                    self.handleWorkspaceSymbol(system, parameters)
+                }
+            | "shutdown" => Result(Json.null().write())
+            | _ => self.handleUnsupported()
+        }
+    }
+
+    handleTokenRequestWithCache(
+        system: NodeSystem
+        method: String
+        parameters: Map[String, Json]
+        handle: TokenRequestCacheKey => ResultOrError
+    ): ResultOrError {
+        let targetAt = self.findTokenFromParameters(system, parameters)
+        let includeDeclaration = parameters.get("context").{
+            | Some(context) {context.field("includeDeclaration") | includeDeclaration} {includeDeclaration.getBool() | Some(b)} => b
+            | _ => True
+        }        
+        let cacheKey = TokenRequestCacheKey(method, targetAt, includeDeclaration)
+        self.responseCache.get(cacheKey).{
+            | Some(hit) => hit
+            | None => 
+                let result = handle(cacheKey)
+                self.responseCache = self.responseCache.add(cacheKey, result)
+                result
+        }
+    }
+
+    handleUnsupported(): ResultOrError {
+        Error(1234, "Unsupported method")
+    }
+
+    handleInitialize(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
+        self.rootPath = parameters.grab("rootUri").getString().map {system.pathFromUrl(_)}
+
+        let anyFireflyFile = Json.object()
+            .with("filters", [
+                Json.object()
+                    .with("pattern", Json.object()
+                        .with("glob", "**/*.ff")
+                        .with("matches", "file")
+                    )
+            ])
+
+        let o = Json.object()
+            .with("capabilities", Json.object()
+                .with("textDocumentSync", Json.object()
+                    .with("openClose", True)
+                    .with("change", 1 /* TextDocumentSyncKind.Full */)
+                )
+                .with("hoverProvider", True)
+                .with("definitionProvider", True)
+                .with("documentHighlightProvider", True)
+                /*.with("diagnosticProvider", Json.object()
+                    .with("interFileDependencies", False)
+                    .with("workspaceDiagnostics", False)
+                )*/
+                .with("documentSymbolProvider", True)
+                .with("completionProvider", Json.object()
+                    .with("triggerCharacters", [".", " ", "("])
+                    .with("allCommitCharacters", [";"])
+                )
+                .with("signatureHelpProvider", Json.object()
+                    .with("triggerCharacters", ["("])
+                    .with("retriggerCharacters", [","])
+                )
+                .with("referencesProvider", True)
+                .with("workspaceSymbolProvider", True)
+                .with("workspace", Json.object()
+                    .with("fileOperations", Json.object()
+                        .with("didRename", anyFireflyFile)
+                        .with("didDelete", anyFireflyFile)
+                    )
+                )
+                /*
+                    .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", Json.object()
+                .with("name", "Firefly Language Server")
+                .with("version", "0.0.0")
+            )
+        Result(o.write())
+    }
+
+    /*handleDiagnostic(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
+        let js = system.js()
+        let uri = parameters.grab("textDocument").field("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        let fireflyPath = system.path(".")
+        let errors = self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, LspHook.disabled(), True)
+        let diagnostics = errors.map {| CompileError(at, message) => 
+            let tokenLocation = self.findToken(system, at)
+            Json.object()
+                .with("range", self.tokenLocationToLspRange(tokenLocation))
+                .with("severity", 1)
+                .with("message", message)
+        }
+        let o = Json.object()
+            .with("kind", "full")
+            .with("items", diagnostics)
+        Result(o.write())
+    }*/
+
+    handleFocusDiagnostic(system: NodeSystem, parameters: Map[String, Json], version: Int): Json {
+        let js = system.js()
+        let uri = parameters.grab("textDocument").field("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        let fireflyPath = system.path(".")
+        let errors = self.check(system, fireflyPath, path, None, Set.new(), self.virtualFiles, version, LspHook.disabled(), True)
+        let diagnostics = errors.filter {_.at.file == path.absolute()}.map {| CompileError(at, message) => 
+            let tokenLocation = self.findToken(system, at)
+            Json.object()
+                .with("range", self.tokenLocationToLspRange(tokenLocation))
+                .with("severity", 1)
+                .with("message", message)
+        }
+        Json.object()
+            .with("uri", uri)
+            .with("version", parameters.grab("textDocument").field("version"))
+            .with("diagnostics", diagnostics)
+    }
+    
+    handleClearDiagnostic(system: NodeSystem, parameters: Map[String, Json]): List[Json] {
+        let js = system.js()
+        let files = parameters.grab("files").grabArray()
+        files.map {file =>
+            let uri = file.getField("uri").else {file.grabField("oldUri")}
+            Json.object()
+                .with("uri", uri)
+                .with("diagnostics", Json.array([]))
+        }
+    }
+    
+    handleDocumentSymbol(system: NodeSystem, parameters: Map[String, Json]): ResultOrError {
+        let uri = parameters.grab("textDocument").field("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        let symbols = self.getDocumentSymbolsWithCache(system, path)
+        let lspSymbols = symbols.map {SymbolHandler.documentSymbolToLsp(_)}
+        Result(Json.array(lspSymbols).write())
+    }
+
+    getDocumentSymbols(system: NodeSystem, path: Path): List[DocumentSymbol] {
+        try {
+            let lspHook = LspHook.new(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.new(PackagePair("script", "script"), path.absolute(), tokens, False, lspHook)
+            parser.parseModuleWithPackageInfo()
+            SymbolHandler.readAllSymbols(lspHook.results())
+        } tryCatch {| CompileError(at, message), error =>
+            Log.trace("handleDocumentSymbol parse error: " + message)
+            []
+        } catch {| ReadSymbolsError e, _ => 
+            Log.trace("handleDocumentSymbol ReadSymbolsError")
+            []
+        }     
+    }
+
+    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, Json]): ResultOrError {
+        self.rootPath.or {Error(-32803 /*Request Failed*/, "Open a folder to enable workspace symbols")}: rootPath =>
+        let files = if(rootPath.isFile()) {
+            [rootPath]
+        } else {
+            self.printTime(system.mainTask(), "findFireflyFiles") {Builder.findFireflyFiles(rootPath, None, Set.new())}
+        }
+        let root = if(rootPath.isFile()) {rootPath.parent().grab()} else {rootPath}
+        let query = parameters.grab("query").grabString()
+        let symbols = files.flatMap {file => 
+            let documentSymbols = self.getDocumentSymbolsWithCache(system, file)
+            let workspaceSymbols = documentSymbols.flatMap {SymbolHandler.documentToWorkspaceSymbols(_, None)}
+            if(query == "") {
+                workspaceSymbols.filter {_.kind == SType}
+            } else {
+                workspaceSymbols.filter {SymbolHandler.symbolFilter(_, query)}
+            }
+        }
+        let limitedSymbols = symbols.sortBy {_.name.size()}.takeFirst(100)
+        let jsSymbols = limitedSymbols.map {SymbolHandler.workspaceSymbolToLsp(root, _)}
+        Result(Json.array(jsSymbols).write())
+    }
+    
+    handleDidChangeWatched(system: NodeSystem, parameters: Map[String, Json]): List[Pair[String, Json]] {
+        let creates = parameters.grab("changes").grabArray().filter {_.field("type").grabInt() == 1}
+        let changes = parameters.grab("changes").grabArray().filter {_.field("type").grabInt() == 2}
+        let deletes = parameters.grab("changes").grabArray().filter {_.field("type").grabInt() == 3}
+        creates.map {_.field("uri").grabString()}.each {self.moduleCache.invalidate(system.pathFromUrl(_).absolute())}
+        changes.map {_.field("uri").grabString()}.each {self.moduleCache.invalidate(system.pathFromUrl(_).absolute())}
+        deletes.map {_.field("uri").grabString()}.each {self.moduleCache.invalidate(system.pathFromUrl(_).absolute())}
+        let diagnostics = self.handleClearDiagnostic(system, [Pair("files", Json.array(deletes))].toMap())
+        diagnostics.map {Pair("textDocument/publishDiagnostics", _)}
+    }
+    
+    handleDidOpen(system: NodeSystem, parameters: Map[String, Json]): Unit {
+        let uri = parameters.grab("textDocument").field("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        if(self.rootPath.isEmpty()) {
+            Log.trace("Using file as rootPath: " + path.absolute())
+            self.rootPath = Some(path)
+        }
+    }
+
+    handleDidChange(system: NodeSystem, parameters: Map[String, Json]): Unit {
+        let uri = parameters.grab("textDocument").field("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        self.responseCache = Map.new()
+        self.fileSymbolsCache = self.fileSymbolsCache.remove(path.absolute())
+        self.moduleCache.invalidate(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.field("range").isNull()) {throw(LanguageServerException("Expected a complete contentChange"))} else:
+        let content = contentChange.field("text").grabString()
+        self.virtualFiles = self.virtualFiles.add(path.absolute(), content)
+    }
+
+    handleDidClose(system: NodeSystem, parameters: Map[String, Json]): Unit {
+        let uri = parameters.grab("textDocument").field("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        self.virtualFiles = self.virtualFiles.remove(path.absolute())
+    }
+
+    handleHover(system: NodeSystem, targetAt: Location, goToDefinition: Bool, version: Int): ResultOrError {
+        let lspHook = LspHook.new(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+        let path = system.path(targetAt.file)
+        let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
+        errors.each {| CompileError(at, message) => 
+            Log.trace("handleHover check error: " + message)
+        }
+        let o = if(goToDefinition) {
+            HoverHandler.handleGoToDefinition(system, self, lspHook)
+        } else {
+            HoverHandler.handleHover(system, self, lspHook)
+        }
+        Result(o.write())
+    }
+
+    handleCompletion(system: NodeSystem, parameters: Map[String, Json], version: Int): 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
+        )
+        let lspHook = LspHook.new(at = Some(completionAt), definedAt = None, insertIdentifier = True, trackSymbols = False)
+        let path = system.path(completionAt.file)
+        let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, lspHook, True)
+        errors.each {| CompileError(at, message) => 
+            Log.trace("handleCompletion check error: " + message)
+        }        
+        let o = CompletionHandler.handleCompletion(lspHook, completionAt.column == 1, token.followedByLeftBracket)
+        Result(o.write())
+    }
+
+    handleSignatureHelp(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
+        let cursorAt = self.findLocationFromParameters(system, parameters)
+        let lspHook = LspHook.new(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.new(PackagePair("script", "script"), cursorAt.file, tokens, False, lspHook)
+            parser.parseModuleWithPackageInfo()
+        } catch {| CompileError(at, message), error =>
+            Log.trace("handleSignatureHelp check error: " + message)
+        }
+        let o = lspHook.results().collectFirst {
+            | ParseArgumentHook h {parameters.get("context") | Some(context)} {
+                context.field("activeSignatureHelp") | help
+            } {!help.isNull() && help.hasField("signatures")} {
+                help.field("signatures").index(0) | activeSignature
+            } {!activeSignature.isNull()} {
+                activeSignature.field("parameters").grabArray().last() | Some(fakeParameter)
+            } {
+                fakeParameter.field("label").grabString() == "/* Call " + h.callAt.show() + " */"
+            } => 
+                Some(SignatureHelpHandler.pickActiveParameter(help, h.argumentIndex, h.parameterName))
+            | ParseArgumentHook h => 
+                let callLspHook = LspHook.new(at = Some(h.callAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+                let path = system.path(cursorAt.file)
+                let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, callLspHook, True)
+                errors.each {| CompileError(at, message) => 
+                    Log.trace("handleSignatureHelp check 2 error: " + message)
+                }        
+                let help = SignatureHelpHandler.handleSignatureHelp(system, callLspHook)
+                if(!help.isNull()) {
+                    SignatureHelpHandler.pickActiveParameter(help, h.argumentIndex, h.parameterName)
+                }
+            | _ => 
+                None
+        }
+        Result((o.else {Json.null()}).write())
+    }
+
+    handleReferences(system: NodeSystem, targetAt: Location, includeDeclaration: Bool, local: Bool, version: Int): ResultOrError {
+        let tokens = self.findReferences(system, targetAt, local, includeDeclaration, version)
+        let o = tokens.{
+            | None => Json.null()
+            | Some(tokens) =>
+                let lspTokens = tokens.map {self.tokenLocationToLspLocation(system, _)}
+                Json.array(lspTokens)
+        }
+        Result(o.write())
+    }
+
+    handleRename(system: NodeSystem, parameters: Map[String, Json], version: Int): ResultOrError {
+        let newName = parameters.grab("newName").grabString()
+        let targetAt = self.findTokenFromParameters(system, parameters)
+        let tokens = self.findReferences(system, targetAt, local = False, includeDeclaration = True, version = version)
+        tokens.{
+            | None => Error(-32602, "Token definition not found") // InvalidParams
+            | Some([]) => Result(Json.null().write())
+            | 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(Json.object(), {| o, Pair(file, fileTokens) =>
+                    let uri = system.path(file).url()
+                    let fileChanges = fileTokens.map {tokenLocation =>
+                        Json.object()
+                            .with("range", self.tokenLocationToLspRange(tokenLocation))
+                            .with("newText", newName)
+                    }
+                    o.with(uri, fileChanges)
+                })
+                let o = Json.object().with("changes", allChanges)
+                Result(o.write())
+        }
+    }
+
+    findReferences(
+        system: NodeSystem
+        targetAt: Location
+        local: Bool
+        includeDeclaration: Bool
+        version: Int
+    ): Option[List[TokenLocation]] {
+        let temporaryLspHook = LspHook.new(at = Some(targetAt), definedAt = None, insertIdentifier = False, trackSymbols = False)
+        let path = system.path(targetAt.file)
+        let errors = self.check(system, self.fireflyPath, path, None, Set.new(), self.virtualFiles, version, temporaryLspHook, True)
+        errors.each {| CompileError(at, message) => 
+            Log.trace("findReferences first check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
+        }  
+                
+        //Log.trace("defined at hooks: " + Show.show(temporaryLspHook.results().map(LspHook.showHook)))
+        let definedAtList = temporaryLspHook.results().collect {
+            | ResolveSymbolHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, local = !h.topLevel))
+            | ResolveVariantFieldHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, False))
+            | ResolveTypeHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, False))
+            | ResolveConstraintHook h => Some(Definition(h.symbol.definedAt, h.symbol.qualifiedName, False))
+            | ResolveSignatureHook h {!h.isInstanceMethod} => Some(Definition(h.signature.at, h.signature.name, local = !h.topLevel))
+            | InferParameterHook h => Some(Definition(h.parameter.at, h.parameter.name, False))
+            | InferArgumentHook h {h.arguments.dropFirst(h.argumentIndex).first() | Some(a)} {a.name | Some(n)} => 
+                h.parameters.find {_.name == n}.map {Definition(_.at, n, False)}
+            | InferLookupHook h => Some(Definition(h.symbol.value.definedAt, h.symbol.value.qualifiedName, False))
+            | InferPatternHook h {h.pattern | PVariantAs p} => Some(Definition(p.variableAt, p.name, False))
+            | InferPatternHook h {h.pattern | PVariable p} => p.name.map {Definition(p.at, _, False)}
+            | InferPatternHook h {h.pattern | PAlias p} => Some(Definition(p.at, p.variable, False))
+            | InferRecordFieldHook h {h.unification.substitute(h.recordType) | TConstructor(_, n, ts)} =>
+                let fieldNames = n.split('$').dropFirst(1)
+                let fieldDefinedAt = fieldNames.zip(ts).collectFirst {| Pair(name, t) =>
+                    if(name == h.fieldName) {t.at}
+                }
+                fieldDefinedAt.map {Definition(_, h.fieldName, False)}
+            | h => None
+        }.filter {pair => !pair.at.file.endsWith(">")}
+            
+        function unqualify(qualifiedName: String): String {
+            qualifiedName.split('.').grabLast().split('_').grabLast()
+        }
+
+        function extractModuleName(qualifiedName: String): String {
+            qualifiedName.split('/').grabLast().takeWhile {c => c != '.' || c == '_'}
+        }
+
+        function extractPackagePair(qualifiedName: String): PackagePair {
+            let group = qualifiedName.split(':').grabFirst()
+            let name = qualifiedName.split(':').grabLast().takeWhile {_ != '/'}
+            PackagePair(group, name)
+        }
+
+        definedAtList.first().{
+            | Some(definition) =>
+                let lspHook = LspHook.new(at = None, definedAt = Some(definition.at), insertIdentifier = False, trackSymbols = False)
+                let localCheck = local || definition.local
+                let path = if(localCheck) {system.path(targetAt.file)} else {self.rootPath.else {system.path(targetAt.file)}}
+                let mustContain = Some(definition.name).filter {_ => !localCheck}.map(unqualify)
+                Log.trace("findReferences definition: " + Show.show(definition))
+                mustContain.each {Log.trace("mustContain: " + _)}
+                
+                let skipFiles = if(definition.name.contains(":")) {
+                    let list = self.moduleCache.filesNotImporting(extractPackagePair(definition.name), extractModuleName(definition.name))
+                    list.toSet()
+                } else {
+                    self.moduleCache.parsedModules.get(definition.at.file).map {| Pair(module, _) =>
+                        let list = self.moduleCache.filesNotImporting(module.packagePair, module.file.dropLast(3))
+                        list.toSet()
+                    }.else {
+                        Log.trace("No skip list due to unqualified definition.name: " + definition.name)
+                        Set.new()
+                    }
+                }
+                let errors = self.check(system, self.fireflyPath, path, mustContain, skipFiles, self.virtualFiles, version, lspHook, True, False)
+                errors.each {| CompileError(at, message) => 
+                    Log.trace("findReferences second check error: " + message + " in " + at.file + ":" + at.line + ":" + at.column)
+                }
+
+                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)
+                    | InferRecordFieldHook h => Some(h.usageAt)
+                    | _ => None
+                }.filter {at => 
+                    !at.file.endsWith(">") &&
+                    (includeDeclaration || at != definition.at)
+                }
+                
+                //referencesResult.each {Log.trace(Show.show(_))}
+
+                let clientLocations = referencesResult.addAll(
+                    if(includeDeclaration) {[definition.at]} else {[]}
+                ).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(method: String, params: Json): Json {
+        Json.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
+        }
+    }
+
+    findTokenFromParameters(system: NodeSystem, parameters: Map[String, Json]): 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, Json]): Location {
+        let uri = parameters.grab("textDocument").field("uri").grabString()
+        let path = system.pathFromUrl(uri)
+        let line = parameters.grab("position").field("line").grabInt() + 1
+        let column = parameters.grab("position").field("character").grabInt() + 1
+        Location(path.absolute(), line, column)
+    }
+
+    tokenLocationToLspLocation(system: NodeSystem, tokenLocation: TokenLocation): Json {
+        Json.object()
+            .with("uri", system.path(tokenLocation.file).url())
+            .with("range", self.tokenLocationToLspRange(tokenLocation))
+    }
+
+    tokenLocationToLspRange(tokenLocation: TokenLocation): Json {
+        Json.object()
+            .with("start", Json.object()
+                .with("line", tokenLocation.startLine - 1)
+                .with("character", tokenLocation.startColumn - 1)
+            )
+            .with("end", Json.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
+    }
+    
+    check(
+        system: NodeSystem
+        fireflyPath: Path
+        path: Path
+        mustContain: Option[String]
+        skipFiles: Set[String]
+        virtualFiles: Map[String, String]
+        newModuleCacheVersion: Int
+        lspHook: LspHook
+        infer: Bool
+        checkDependencies: Bool = True
+    ): List[CompileError] {
+        Builder.check(
+            system
+            fireflyPath
+            path
+            mustContain
+            skipFiles
+            virtualFiles
+            self.moduleCache
+            self.dependencyLock
+            newModuleCacheVersion
+            lspHook
+            infer
+            checkDependencies
+        )
+    }
+
+}