| import anser from "anser"; | |
| import * as lc from "vscode-languageclient/node"; | |
| import * as vscode from "vscode"; | |
| import * as ra from "../src/lsp_ext"; | |
| import * as Is from "vscode-languageclient/lib/common/utils/is"; | |
| import { assert } from "./util"; | |
| import * as diagnostics from "./diagnostics"; | |
| import { WorkspaceEdit } from "vscode"; | |
| import { type Config, prepareVSCodeConfig } from "./config"; | |
| import { sep as pathSeparator } from "path"; | |
| import { RaLanguageClient } from "./lang_client"; | |
| export async function createClient( | |
| traceOutputChannel: vscode.OutputChannel, | |
| outputChannel: vscode.OutputChannel, | |
| initializationOptions: lc.LanguageClientOptions["initializationOptions"], | |
| serverOptions: lc.ServerOptions, | |
| config: Config, | |
| unlinkedFiles: vscode.Uri[], | |
| ): Promise<lc.LanguageClient> { | |
| const raMiddleware: lc.Middleware = { | |
| workspace: { | |
| // HACK: This is a workaround, when the client has been disposed, VSCode | |
| // continues to emit events to the client and the default one for this event | |
| // attempt to restart the client for no reason | |
| async didChangeWatchedFile(event, next) { | |
| if (client.isRunning()) { | |
| await next(event); | |
| } | |
| }, | |
| async configuration( | |
| params: lc.ConfigurationParams, | |
| _token: vscode.CancellationToken, | |
| _next: lc.ConfigurationRequest.HandlerSignature, | |
| ) { | |
| // The rust-analyzer LSP only ever asks for the "rust-analyzer" | |
| // section, so we only need to support that. Instead of letting | |
| // the vscode-languageclient handle it, use the `cfg` property | |
| // in the config. | |
| if ( | |
| params.items.length !== 1 || | |
| params.items[0]?.section !== "rust-analyzer" || | |
| params.items[0]?.scopeUri !== undefined | |
| ) { | |
| return new lc.ResponseError( | |
| lc.ErrorCodes.InvalidParams, | |
| 'Only the "rust-analyzer" config section is supported.', | |
| ); | |
| } | |
| return [prepareVSCodeConfig(config.cfg)]; | |
| }, | |
| }, | |
| async handleDiagnostics( | |
| uri: vscode.Uri, | |
| diagnosticList: vscode.Diagnostic[], | |
| next: lc.HandleDiagnosticsSignature, | |
| ) { | |
| const preview = config.previewRustcOutput; | |
| const errorCode = config.useRustcErrorCode; | |
| diagnosticList.forEach((diag, idx) => { | |
| const value = | |
| typeof diag.code === "string" || typeof diag.code === "number" | |
| ? diag.code | |
| : diag.code?.value; | |
| if ( | |
| // FIXME: We currently emit this diagnostic way too early, before we have | |
| // loaded the project fully | |
| // value === "unlinked-file" && | |
| value === "temporary-disabled" && | |
| !unlinkedFiles.includes(uri) && | |
| (diag.message === "file not included in crate hierarchy" || | |
| diag.message.startsWith("This file is not included in any crates")) | |
| ) { | |
| const config = vscode.workspace.getConfiguration("rust-analyzer"); | |
| if (config.get("showUnlinkedFileNotification")) { | |
| unlinkedFiles.push(uri); | |
| const folder = vscode.workspace.getWorkspaceFolder(uri)?.uri.fsPath; | |
| if (folder) { | |
| const parentBackslash = uri.fsPath.lastIndexOf(pathSeparator + "src"); | |
| const parent = uri.fsPath.substring(0, parentBackslash); | |
| if (parent.startsWith(folder)) { | |
| const path = vscode.Uri.file(parent + pathSeparator + "Cargo.toml"); | |
| void vscode.workspace.fs.stat(path).then(async () => { | |
| const choice = await vscode.window.showInformationMessage( | |
| `This rust file does not belong to a loaded cargo project. It looks like it might belong to the workspace at ${path.path}, do you want to add it to the linked Projects?`, | |
| "Yes", | |
| "No", | |
| "Don't show this again", | |
| ); | |
| switch (choice) { | |
| case undefined: | |
| break; | |
| case "No": | |
| break; | |
| case "Yes": { | |
| const pathToInsert = | |
| "." + | |
| parent.substring(folder.length) + | |
| pathSeparator + | |
| "Cargo.toml"; | |
| const value = config | |
| // eslint-disable-next-line @typescript-eslint/no-explicit-any | |
| .get<any[]>("linkedProjects") | |
| ?.concat(pathToInsert); | |
| await config.update("linkedProjects", value, false); | |
| break; | |
| } | |
| case "Don't show this again": | |
| await config.update( | |
| "showUnlinkedFileNotification", | |
| false, | |
| false, | |
| ); | |
| break; | |
| } | |
| }); | |
| } | |
| } | |
| } | |
| } | |
| // Abuse the fact that VSCode leaks the LSP diagnostics data field through the | |
| // Diagnostic class, if they ever break this we are out of luck and have to go | |
| // back to the worst diagnostics experience ever:) | |
| // We encode the rendered output of a rustc diagnostic in the rendered field of | |
| // the data payload of the lsp diagnostic. If that field exists, overwrite the | |
| // diagnostic code such that clicking it opens the diagnostic in a readonly | |
| // text editor for easy inspection | |
| const rendered = (diag as unknown as { data?: { rendered?: string } }).data | |
| ?.rendered; | |
| if (rendered) { | |
| if (preview) { | |
| const decolorized = anser.ansiToText(rendered); | |
| const index = decolorized.match(/^(note|help):/m)?.index || rendered.length; | |
| diag.message = decolorized | |
| .substring(0, index) | |
| .replace(/^ -->[^\n]+\n/m, ""); | |
| } | |
| diag.code = { | |
| target: vscode.Uri.from({ | |
| scheme: diagnostics.URI_SCHEME, | |
| path: `/diagnostic message [${idx.toString()}]`, | |
| fragment: uri.toString(), | |
| query: idx.toString(), | |
| }), | |
| value: errorCode && value ? value : "Click for full compiler diagnostic", | |
| }; | |
| } | |
| }); | |
| return next(uri, diagnosticList); | |
| }, | |
| async provideHover( | |
| document: vscode.TextDocument, | |
| position: vscode.Position, | |
| token: vscode.CancellationToken, | |
| _next: lc.ProvideHoverSignature, | |
| ) { | |
| const editor = vscode.window.activeTextEditor; | |
| const positionOrRange = editor?.selection?.contains(position) | |
| ? client.code2ProtocolConverter.asRange(editor.selection) | |
| : client.code2ProtocolConverter.asPosition(position); | |
| const params = { | |
| textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), | |
| position: positionOrRange, | |
| }; | |
| return client.sendRequest(ra.hover, params, token).then( | |
| (result) => { | |
| if (!result) return null; | |
| const hover = client.protocol2CodeConverter.asHover(result); | |
| if (result.actions) { | |
| hover.contents.push(renderHoverActions(result.actions)); | |
| } | |
| return hover; | |
| }, | |
| (error) => { | |
| client.handleFailedRequest(lc.HoverRequest.type, token, error, null); | |
| return Promise.resolve(null); | |
| }, | |
| ); | |
| }, | |
| // Using custom handling of CodeActions to support action groups and snippet edits. | |
| // Note that this means we have to re-implement lazy edit resolving ourselves as well. | |
| async provideCodeActions( | |
| document: vscode.TextDocument, | |
| range: vscode.Range, | |
| context: vscode.CodeActionContext, | |
| token: vscode.CancellationToken, | |
| _next: lc.ProvideCodeActionsSignature, | |
| ) { | |
| const params: lc.CodeActionParams = { | |
| textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document), | |
| range: client.code2ProtocolConverter.asRange(range), | |
| context: await client.code2ProtocolConverter.asCodeActionContext(context, token), | |
| }; | |
| const callback = async ( | |
| values: (lc.Command | lc.CodeAction | object)[] | null, | |
| ): Promise<(vscode.Command | vscode.CodeAction)[] | undefined> => { | |
| if (values === null) return undefined; | |
| const result: (vscode.CodeAction | vscode.Command)[] = []; | |
| const groups = new Map< | |
| string, | |
| { | |
| primary: vscode.CodeAction; | |
| items: { label: string; arguments: lc.CodeAction }[]; | |
| } | |
| >(); | |
| for (const item of values) { | |
| // In our case we expect to get code edits only from diagnostics | |
| if (lc.CodeAction.is(item)) { | |
| assert(!item.command, "We don't expect to receive commands in CodeActions"); | |
| const action = await client.protocol2CodeConverter.asCodeAction( | |
| item, | |
| token, | |
| ); | |
| result.push(action); | |
| continue; | |
| } | |
| assertIsCodeActionWithoutEditsAndCommands(item); | |
| const kind = client.protocol2CodeConverter.asCodeActionKind(item.kind); | |
| const group = item.group; | |
| const mkAction = () => { | |
| const action = new vscode.CodeAction(item.title, kind); | |
| action.command = { | |
| command: "rust-analyzer.resolveCodeAction", | |
| title: item.title, | |
| arguments: [item], | |
| }; | |
| // Set a dummy edit, so that VS Code doesn't try to resolve this. | |
| action.edit = new WorkspaceEdit(); | |
| return action; | |
| }; | |
| if (group) { | |
| let entry = groups.get(group); | |
| if (!entry) { | |
| entry = { primary: mkAction(), items: [] }; | |
| groups.set(group, entry); | |
| } else { | |
| entry.items.push({ | |
| label: item.title, | |
| arguments: item, | |
| }); | |
| } | |
| } else { | |
| result.push(mkAction()); | |
| } | |
| } | |
| for (const [group, { items, primary }] of groups) { | |
| // This group contains more than one item, so rewrite it to be a group action | |
| if (items.length !== 0) { | |
| const args = [ | |
| { | |
| label: primary.title, | |
| arguments: primary.command!.arguments![0], | |
| }, | |
| ...items, | |
| ]; | |
| primary.title = group; | |
| primary.command = { | |
| command: "rust-analyzer.applyActionGroup", | |
| title: "", | |
| arguments: [args], | |
| }; | |
| } | |
| result.push(primary); | |
| } | |
| return result; | |
| }; | |
| return client | |
| .sendRequest(lc.CodeActionRequest.type, params, token) | |
| .then(callback, (_error) => undefined); | |
| }, | |
| }; | |
| const clientOptions: lc.LanguageClientOptions = { | |
| documentSelector: [{ scheme: "file", language: "rust" }], | |
| initializationOptions, | |
| diagnosticCollectionName: "rustc", | |
| traceOutputChannel, | |
| outputChannel, | |
| middleware: raMiddleware, | |
| markdown: { | |
| supportHtml: true, | |
| }, | |
| }; | |
| const client = new RaLanguageClient( | |
| "rust-analyzer", | |
| "Rust Analyzer Language Server", | |
| serverOptions, | |
| clientOptions, | |
| ); | |
| // To turn on all proposed features use: client.registerProposedFeatures(); | |
| client.registerFeature(new ExperimentalFeatures(config)); | |
| client.registerFeature(new OverrideFeatures()); | |
| return client; | |
| } | |
| class ExperimentalFeatures implements lc.StaticFeature { | |
| private readonly testExplorer: boolean; | |
| constructor(config: Config) { | |
| this.testExplorer = config.testExplorer || false; | |
| } | |
| getState(): lc.FeatureState { | |
| return { kind: "static" }; | |
| } | |
| fillClientCapabilities(capabilities: lc.ClientCapabilities): void { | |
| capabilities.experimental = { | |
| snippetTextEdit: true, | |
| codeActionGroup: true, | |
| hoverActions: true, | |
| serverStatusNotification: true, | |
| colorDiagnosticOutput: true, | |
| openServerLogs: true, | |
| localDocs: true, | |
| testExplorer: this.testExplorer, | |
| commands: { | |
| commands: [ | |
| "rust-analyzer.runSingle", | |
| "rust-analyzer.debugSingle", | |
| "rust-analyzer.showReferences", | |
| "rust-analyzer.gotoLocation", | |
| "rust-analyzer.triggerParameterHints", | |
| "rust-analyzer.rename", | |
| ], | |
| }, | |
| ...capabilities.experimental, | |
| }; | |
| } | |
| initialize( | |
| _capabilities: lc.ServerCapabilities, | |
| _documentSelector: lc.DocumentSelector | undefined, | |
| ): void {} | |
| dispose(): void {} | |
| clear(): void {} | |
| } | |
| class OverrideFeatures implements lc.StaticFeature { | |
| getState(): lc.FeatureState { | |
| return { kind: "static" }; | |
| } | |
| fillClientCapabilities(capabilities: lc.ClientCapabilities): void { | |
| // Force disable `augmentsSyntaxTokens`, VSCode's textmate grammar is somewhat incomplete | |
| // making the experience generally worse | |
| const caps = capabilities.textDocument?.semanticTokens; | |
| if (caps) { | |
| caps.augmentsSyntaxTokens = false; | |
| } | |
| } | |
| initialize( | |
| _capabilities: lc.ServerCapabilities, | |
| _documentSelector: lc.DocumentSelector | undefined, | |
| ): void {} | |
| dispose(): void {} | |
| clear(): void {} | |
| } | |
| function assertIsCodeActionWithoutEditsAndCommands( | |
| // eslint-disable-next-line @typescript-eslint/no-explicit-any | |
| candidate: any, | |
| ): asserts candidate is lc.CodeAction & { | |
| group?: string; | |
| } { | |
| assert( | |
| candidate && | |
| Is.string(candidate.title) && | |
| (candidate.diagnostics === undefined || | |
| Is.typedArray(candidate.diagnostics, lc.Diagnostic.is)) && | |
| (candidate.group === undefined || Is.string(candidate.group)) && | |
| (candidate.kind === undefined || Is.string(candidate.kind)) && | |
| candidate.edit === undefined && | |
| candidate.command === undefined, | |
| `Expected a CodeAction without edits or commands, got: ${JSON.stringify(candidate)}`, | |
| ); | |
| } | |
| // Command URIs have a form of command:command-name?arguments, where | |
| // arguments is a percent-encoded array of data we want to pass along to | |
| // the command function. For "Show References" this is a list of all file | |
| // URIs with locations of every reference, and it can get quite long. | |
| // So long in fact that it will fail rendering inside an `a` tag so we need | |
| // to proxy around that. We store the last hover's reference command link | |
| // here, as only one hover can be active at a time, and we don't need to | |
| // keep a history of these. | |
| export let HOVER_REFERENCE_COMMAND: ra.CommandLink[] = []; | |
| function renderCommand(cmd: ra.CommandLink): string { | |
| HOVER_REFERENCE_COMMAND.push(cmd); | |
| return `[${cmd.title}](command:rust-analyzer.hoverRefCommandProxy?${ | |
| HOVER_REFERENCE_COMMAND.length - 1 | |
| } '${cmd.tooltip}')`; | |
| } | |
| function renderHoverActions(actions: ra.CommandLinkGroup[]): vscode.MarkdownString { | |
| // clean up the previous hover ref command | |
| HOVER_REFERENCE_COMMAND = []; | |
| const text = actions | |
| .map( | |
| (group) => | |
| (group.title ? group.title + " " : "") + | |
| group.commands.map(renderCommand).join(" | "), | |
| ) | |
| .join(" | "); | |
| const result = new vscode.MarkdownString(text); | |
| result.isTrusted = true; | |
| return result; | |
| } |