rust/editors/code/src/client.ts

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

350 lines
15 KiB
TypeScript
Raw Normal View History

import * as 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 { Config, substituteVSCodeVariables } from "./config";
import { randomUUID } from "crypto";
2019-12-31 11:14:00 -06:00
export interface Env {
[name: string]: string;
}
// 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.
//
// To work around it we use an intermediary linkToCommand command. When
// we render a command link, a reference to a command with all its arguments
// is stored in a map, and instead a linkToCommand link is rendered
// with the key to that map.
export const LINKED_COMMANDS = new Map<string, ra.CommandLink>();
// For now the map is cleaned up periodically (I've set it to every
// 10 minutes). In general case we'll probably need to introduce TTLs or
// flags to denote ephemeral links (like these in hover popups) and
// persistent links and clean those separately. But for now simply keeping
// the last few links in the map should be good enough. Likewise, we could
// add code to remove a target command from the map after the link is
// clicked, but assuming most links in hover sheets won't be clicked anyway
// this code won't change the overall memory use much.
setInterval(function cleanupOlderCommandLinks() {
// keys are returned in insertion order, we'll keep a few
// of recent keys available, and clean the rest
const keys = [...LINKED_COMMANDS.keys()];
const keysToRemove = keys.slice(0, keys.length - 10);
for (const key of keysToRemove) {
LINKED_COMMANDS.delete(key);
}
}, 10 * 60 * 1000);
function renderCommand(cmd: ra.CommandLink): string {
const commandId = randomUUID();
LINKED_COMMANDS.set(commandId, cmd);
return `[${cmd.title}](command:rust-analyzer.linkToCommand?${encodeURIComponent(
JSON.stringify([commandId])
2021-02-07 11:45:13 -06:00
)} '${cmd.tooltip}')`;
2020-06-03 06:15:54 -05:00
}
function renderHoverActions(actions: ra.CommandLinkGroup[]): vscode.MarkdownString {
2020-06-03 06:15:54 -05:00
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;
}
export async function createClient(
2022-10-17 07:20:14 -05:00
traceOutputChannel: vscode.OutputChannel,
outputChannel: vscode.OutputChannel,
initializationOptions: vscode.WorkspaceConfiguration,
serverOptions: lc.ServerOptions,
config: Config
): Promise<lc.LanguageClient> {
2019-12-31 11:14:00 -06:00
const clientOptions: lc.LanguageClientOptions = {
documentSelector: [{ scheme: "file", language: "rust" }],
initializationOptions,
diagnosticCollectionName: "rustc",
2022-10-17 07:20:14 -05:00
traceOutputChannel,
outputChannel,
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
) {
const resp = await next(params, token);
if (resp && Array.isArray(resp)) {
return resp.map((val) => {
return substituteVSCodeVariables(val);
});
} else {
return resp;
}
},
},
async handleDiagnostics(
uri: vscode.Uri,
diagnosticList: vscode.Diagnostic[],
next: lc.HandleDiagnosticsSignature
) {
const preview = config.previewRustcOutput;
2022-12-27 00:13:38 -06:00
const errorCode = config.useRustcErrorCode;
diagnosticList.forEach((diag, idx) => {
// 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);
2022-12-27 00:13:38 -06:00
const index =
decolorized.match(/^(note|help):/m)?.index || rendered.length;
diag.message = decolorized
.substring(0, index)
.replace(/^ -->[^\n]+\n/m, "");
}
2022-12-27 00:13:38 -06:00
let value;
if (errorCode) {
if (typeof diag.code === "string" || typeof diag.code === "number") {
value = diag.code;
} else {
value = diag.code?.value;
}
}
diag.code = {
target: vscode.Uri.from({
scheme: diagnostics.URI_SCHEME,
path: `/diagnostic message [${idx.toString()}]`,
fragment: uri.toString(),
query: idx.toString(),
}),
2022-12-27 00:13:38 -06:00
value: value ?? "Click for full compiler diagnostic",
};
}
});
return next(uri, diagnosticList);
},
2020-06-03 06:15:54 -05:00
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);
return client
.sendRequest(
ra.hover,
{
textDocument:
client.code2ProtocolConverter.asTextDocumentIdentifier(document),
position: positionOrRange,
},
token
2022-05-17 12:15:06 -05:00
)
.then(
(result) => {
const hover = client.protocol2CodeConverter.asHover(result);
if (hover) {
2020-06-03 06:15:54 -05:00
const actions = (<any>result).actions;
if (actions) {
hover.contents.push(renderHoverActions(actions));
2022-05-17 12:15:06 -05:00
}
2020-06-03 06:15:54 -05:00
}
return hover;
2022-05-17 12:15:06 -05:00
},
(error) => {
2022-04-08 06:24:28 -05:00
client.handleFailedRequest(lc.HoverRequest.type, token, error, null);
return Promise.resolve(null);
}
);
2020-06-03 06:15:54 -05:00
},
// 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),
2022-04-08 06:24:28 -05:00
context: await client.code2ProtocolConverter.asCodeActionContext(
context,
token
2022-05-17 12:15:06 -05:00
),
};
2022-04-08 06:24:28 -05:00
return client.sendRequest(lc.CodeActionRequest.type, params, token).then(
async (values) => {
if (values === null) return undefined;
const result: (vscode.CodeAction | vscode.Command)[] = [];
2020-05-22 10:29:55 -05:00
const groups = new Map<
string,
{ index: number; items: vscode.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
);
2020-05-22 10:29:55 -05:00
result.push(action);
continue;
2020-05-22 10:29:55 -05:00
}
2022-05-17 12:15:06 -05:00
assert(
isCodeActionWithoutEditsAndCommands(item),
2020-05-22 10:29:55 -05:00
"We don't expect edits or commands here"
2022-05-17 12:15:06 -05:00
);
2020-05-22 10:29:55 -05:00
const kind = client.protocol2CodeConverter.asCodeActionKind(
(item as any).kind
);
const action = new vscode.CodeAction(item.title, kind);
const group = (item as any).group;
2020-05-22 10:29:55 -05:00
action.command = {
command: "rust-analyzer.resolveCodeAction",
2021-02-07 12:36:16 -06:00
title: item.title,
arguments: [item],
2020-05-22 10:29:55 -05:00
};
// Set a dummy edit, so that VS Code doesn't try to resolve this.
action.edit = new WorkspaceEdit();
if (group) {
let entry = groups.get(group);
if (!entry) {
2020-05-22 10:29:55 -05:00
entry = { index: result.length, items: [] };
groups.set(group, entry);
2020-05-22 10:29:55 -05:00
result.push(action);
2022-05-17 12:15:06 -05:00
}
entry.items.push(action);
2022-05-17 12:15:06 -05:00
} else {
result.push(action);
2022-05-17 12:15:06 -05:00
}
2020-05-22 10:29:55 -05:00
}
for (const [group, { index, items }] of groups) {
if (items.length === 1) {
result[index] = items[0];
} else {
2022-04-08 06:24:28 -05:00
const action = new vscode.CodeAction(group);
action.kind = items[0].kind;
2020-05-22 10:29:55 -05:00
action.command = {
command: "rust-analyzer.applyActionGroup",
2020-05-22 10:29:55 -05:00
title: "",
arguments: [
items.map((item) => {
2022-05-17 12:15:06 -05:00
return {
label: item.title,
2021-02-07 12:36:16 -06:00
arguments: item.command!.arguments![0],
2022-05-17 12:15:06 -05:00
};
}),
],
};
// Set a dummy edit, so that VS Code doesn't try to resolve this.
action.edit = new WorkspaceEdit();
2022-05-17 12:15:06 -05:00
2020-05-22 10:29:55 -05:00
result[index] = action;
2022-05-17 12:15:06 -05:00
}
}
return result;
},
(_error) => undefined
);
},
2022-01-14 17:20:35 -06:00
},
markdown: {
supportHtml: true,
2020-08-09 17:09:27 -05:00
},
2019-12-31 11:14:00 -06:00
};
2020-05-17 14:24:33 -05:00
const client = new lc.LanguageClient(
2019-12-31 11:14:00 -06:00
"rust-analyzer",
"Rust Analyzer Language Server",
serverOptions,
clientOptions
);
// To turn on all proposed features use: client.registerProposedFeatures();
2020-05-22 10:29:55 -05:00
client.registerFeature(new ExperimentalFeatures());
2020-05-17 14:24:33 -05:00
return client;
}
2020-05-22 10:29:55 -05:00
class ExperimentalFeatures implements lc.StaticFeature {
2022-10-17 07:20:14 -05:00
getState(): lc.FeatureState {
return { kind: "static" };
}
2020-05-17 14:24:33 -05:00
fillClientCapabilities(capabilities: lc.ClientCapabilities): void {
const caps: any = capabilities.experimental ?? {};
caps.snippetTextEdit = true;
2020-05-22 10:29:55 -05:00
caps.codeActionGroup = true;
2020-06-03 06:15:54 -05:00
caps.hoverActions = true;
2021-04-06 06:16:35 -05:00
caps.serverStatusNotification = true;
caps.colorDiagnosticOutput = true;
caps.openServerLogs = true;
caps.commands = {
commands: [
"rust-analyzer.runSingle",
"rust-analyzer.debugSingle",
"rust-analyzer.showReferences",
"rust-analyzer.gotoLocation",
"editor.action.triggerParameterHints",
],
};
capabilities.experimental = caps;
2020-05-17 14:24:33 -05:00
}
initialize(
_capabilities: lc.ServerCapabilities<any>,
_documentSelector: lc.DocumentSelector | undefined
): void {}
dispose(): void {}
2019-12-31 11:14:00 -06:00
}
function isCodeActionWithoutEditsAndCommands(value: any): boolean {
const candidate: lc.CodeAction = value;
return (
candidate &&
Is.string(candidate.title) &&
(candidate.diagnostics === void 0 ||
Is.typedArray(candidate.diagnostics, lc.Diagnostic.is)) &&
(candidate.kind === void 0 || Is.string(candidate.kind)) &&
candidate.edit === void 0 &&
candidate.command === void 0
);
2020-05-22 10:29:55 -05:00
}