rust/editors/code/src/client.ts

205 lines
9.0 KiB
TypeScript
Raw Normal View History

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 { WorkspaceEdit } from 'vscode';
import { Workspace } from './ctx';
2019-12-31 11:14:00 -06:00
export interface Env {
[name: string]: string;
}
function renderCommand(cmd: ra.CommandLink) {
2021-02-07 11:45:13 -06:00
return `[${cmd.title}](command:${cmd.command}?${encodeURIComponent(JSON.stringify(cmd.arguments))} '${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 function createClient(serverPath: string, workspace: Workspace, extraEnv: Env): lc.LanguageClient {
2019-12-31 11:14:00 -06:00
// '.' Is the fallback if no folder is open
2020-02-04 16:13:46 -06:00
// TODO?: Workspace folders support Uri's (eg: file://test.txt).
// It might be a good idea to test if the uri points to a file.
2019-12-31 11:14:00 -06:00
const newEnv = Object.assign({}, process.env);
Object.assign(newEnv, extraEnv);
2019-12-31 11:14:00 -06:00
const run: lc.Executable = {
2020-02-14 16:42:32 -06:00
command: serverPath,
2021-05-25 17:11:52 -05:00
options: { env: newEnv },
2019-12-31 11:14:00 -06:00
};
const serverOptions: lc.ServerOptions = {
run,
debug: run,
};
const traceOutputChannel = vscode.window.createOutputChannel(
2019-12-31 11:14:00 -06:00
'Rust Analyzer Language Server Trace',
);
let initializationOptions = vscode.workspace.getConfiguration("rust-analyzer");
2021-05-23 15:47:58 -05:00
if (workspace.kind === "Detached Files") {
initializationOptions = { "detachedFiles": workspace.files.map(file => file.uri.fsPath), ...initializationOptions };
}
2019-12-31 11:14:00 -06:00
const clientOptions: lc.LanguageClientOptions = {
documentSelector: [{ scheme: 'file', language: 'rust' }],
initializationOptions,
diagnosticCollectionName: "rustc",
2019-12-31 11:14:00 -06:00
traceOutputChannel,
middleware: {
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).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));
2020-06-03 06:15:54 -05:00
}
}
return hover;
},
(error) => {
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),
context: client.code2ProtocolConverter.asCodeActionContext(context)
};
return client.sendRequest(lc.CodeActionRequest.type, params, token).then((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 = client.protocol2CodeConverter.asCodeAction(item);
result.push(action);
continue;
}
assert(isCodeActionWithoutEditsAndCommands(item), "We don't expect edits or commands here");
const kind = client.protocol2CodeConverter.asCodeActionKind((item as any).kind);
const action = new vscode.CodeAction(item.title, kind);
const group = (item as any).group;
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();
if (group) {
let entry = groups.get(group);
if (!entry) {
entry = { index: result.length, items: [] };
groups.set(group, entry);
2020-05-22 10:29:55 -05:00
result.push(action);
}
entry.items.push(action);
} else {
result.push(action);
}
}
2020-05-22 10:29:55 -05:00
for (const [group, { index, items }] of groups) {
if (items.length === 1) {
result[index] = items[0];
} else {
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",
title: "",
arguments: [items.map((item) => {
2021-02-07 12:36:16 -06:00
return { label: item.title, arguments: item.command!.arguments![0] };
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();
2020-05-22 10:29:55 -05:00
result[index] = action;
}
}
return result;
},
(_error) => undefined
);
}
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 {
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.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
}