2020-09-01 11:53:07 -05:00
|
|
|
import * as lc from 'vscode-languageclient/node';
|
2020-02-13 14:48:20 -06:00
|
|
|
import * as vscode from 'vscode';
|
2020-06-02 15:21:48 -05:00
|
|
|
import * as ra from '../src/lsp_ext';
|
2020-09-01 11:53:07 -05:00
|
|
|
import * as Is from 'vscode-languageclient/lib/common/utils/is';
|
2020-06-02 15:21:48 -05:00
|
|
|
import { assert } from './util';
|
2020-11-10 11:20:01 -06:00
|
|
|
import { WorkspaceEdit } from 'vscode';
|
2021-05-23 08:22:13 -05:00
|
|
|
import { Workspace } from './ctx';
|
2019-12-31 11:14:00 -06:00
|
|
|
|
2020-12-30 03:17:25 -06:00
|
|
|
export interface Env {
|
|
|
|
[name: string]: string;
|
|
|
|
}
|
|
|
|
|
2020-06-05 07:25:01 -05:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2020-06-05 07:25:01 -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;
|
|
|
|
}
|
|
|
|
|
2021-05-23 08:22:13 -05:00
|
|
|
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
|
|
|
|
2020-12-30 03:17:25 -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,
|
|
|
|
};
|
2020-02-13 14:48:20 -06:00
|
|
|
const traceOutputChannel = vscode.window.createOutputChannel(
|
2019-12-31 11:14:00 -06:00
|
|
|
'Rust Analyzer Language Server Trace',
|
|
|
|
);
|
2020-02-13 14:48:20 -06:00
|
|
|
|
2021-05-23 08:22:13 -05:00
|
|
|
let initializationOptions = vscode.workspace.getConfiguration("rust-analyzer");
|
2021-05-23 15:47:58 -05:00
|
|
|
if (workspace.kind === "Detached Files") {
|
2021-05-23 08:22:13 -05:00
|
|
|
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' }],
|
2021-05-23 08:22:13 -05:00
|
|
|
initializationOptions,
|
2020-07-23 00:32:54 -05:00
|
|
|
diagnosticCollectionName: "rustc",
|
2019-12-31 11:14:00 -06:00
|
|
|
traceOutputChannel,
|
2020-02-27 03:19:56 -06:00
|
|
|
middleware: {
|
2020-06-03 06:15:54 -05:00
|
|
|
async provideHover(document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken, _next: lc.ProvideHoverSignature) {
|
2021-07-25 16:26:54 -05:00
|
|
|
const editor = vscode.window.activeTextEditor;
|
2021-07-26 11:14:14 -05:00
|
|
|
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(
|
2021-07-26 16:33:21 -05:00
|
|
|
(result) => {
|
|
|
|
const hover =
|
2021-07-25 16:26:54 -05:00
|
|
|
client.protocol2CodeConverter.asHover(result);
|
2021-07-26 16:33:21 -05:00
|
|
|
if (hover) {
|
2020-06-03 06:15:54 -05:00
|
|
|
const actions = (<any>result).actions;
|
|
|
|
if (actions) {
|
2021-07-26 16:33:21 -05:00
|
|
|
hover.contents.push(renderHoverActions(actions));
|
2020-06-03 06:15:54 -05:00
|
|
|
}
|
2021-07-26 16:33:21 -05:00
|
|
|
}
|
|
|
|
return hover;
|
|
|
|
},
|
|
|
|
(error) => {
|
|
|
|
client.handleFailedRequest(
|
2021-07-25 16:26:54 -05:00
|
|
|
lc.HoverRequest.type,
|
|
|
|
token,
|
|
|
|
error,
|
|
|
|
null
|
2021-07-26 16:33:21 -05:00
|
|
|
);
|
|
|
|
return Promise.resolve(null);
|
|
|
|
}
|
|
|
|
);
|
2020-06-03 06:15:54 -05:00
|
|
|
},
|
2020-11-10 11:20:01 -06: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.
|
2020-05-17 18:53:55 -05:00
|
|
|
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[] }>();
|
2020-05-17 18:53:55 -05:00
|
|
|
for (const item of values) {
|
2020-06-02 15:21:48 -05:00
|
|
|
// In our case we expect to get code edits only from diagnostics
|
2020-05-17 18:53:55 -05:00
|
|
|
if (lc.CodeAction.is(item)) {
|
2020-06-02 15:21:48 -05:00
|
|
|
assert(!item.command, "We don't expect to receive commands in CodeActions");
|
2020-05-17 18:53:55 -05:00
|
|
|
const action = client.protocol2CodeConverter.asCodeAction(item);
|
2020-06-02 15:21:48 -05:00
|
|
|
result.push(action);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
assert(isCodeActionWithoutEditsAndCommands(item), "We don't expect edits or commands here");
|
2020-06-28 18:59:39 -05:00
|
|
|
const kind = client.protocol2CodeConverter.asCodeActionKind((item as any).kind);
|
|
|
|
const action = new vscode.CodeAction(item.title, kind);
|
2020-06-02 15:21:48 -05:00
|
|
|
const group = (item as any).group;
|
|
|
|
action.command = {
|
|
|
|
command: "rust-analyzer.resolveCodeAction",
|
|
|
|
title: item.title,
|
2020-11-10 11:20:01 -06:00
|
|
|
arguments: [item],
|
2020-06-02 15:21:48 -05:00
|
|
|
};
|
2020-11-10 11:20:01 -06:00
|
|
|
|
|
|
|
// Set a dummy edit, so that VS Code doesn't try to resolve this.
|
|
|
|
action.edit = new WorkspaceEdit();
|
|
|
|
|
2020-06-02 15:21:48 -05:00
|
|
|
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);
|
|
|
|
}
|
2020-06-02 15:21:48 -05:00
|
|
|
entry.items.push(action);
|
2020-05-17 18:53:55 -05:00
|
|
|
} else {
|
2020-06-02 15:21:48 -05:00
|
|
|
result.push(action);
|
2020-05-17 18:53:55 -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 {
|
|
|
|
const action = new vscode.CodeAction(group);
|
2020-06-28 18:59:39 -05:00
|
|
|
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
|
|
|
})],
|
|
|
|
};
|
2020-11-10 11:20:01 -06: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;
|
|
|
|
}
|
|
|
|
}
|
2020-05-17 18:53:55 -05:00
|
|
|
return result;
|
|
|
|
},
|
|
|
|
(_error) => undefined
|
|
|
|
);
|
2020-02-27 03:19:56 -06:00
|
|
|
}
|
2020-05-17 18:53:55 -05:00
|
|
|
|
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,
|
|
|
|
);
|
|
|
|
|
2020-05-17 18:53:55 -05:00
|
|
|
// To turn on all proposed features use: client.registerProposedFeatures();
|
2020-05-22 10:29:55 -05:00
|
|
|
client.registerFeature(new ExperimentalFeatures());
|
2020-02-26 07:42:26 -06:00
|
|
|
|
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;
|
feat: gate custom clint-side commands behind capabilities
Some features of rust-analyzer requires support for custom commands on
the client side. Specifically, hover & code lens need this.
Stock LSP doesn't have a way for the server to know which client-side
commands are available. For that reason, we historically were just
sending the commands, not worrying whether the client supports then or
not.
That's not really great though, so in this PR we add infrastructure for
the client to explicitly opt-into custom commands, via `extensions`
field of the ClientCapabilities.
To preserve backwards compatability, if the client doesn't set the
field, we assume that it does support all custom commands. In the
future, we'll start treating that case as if the client doesn't support
commands.
So, if you maintain a rust-analyzer client and implement
`rust-analyzer/runSingle` and such, please also advertise this via a
capability.
2021-07-30 11:16:33 -05:00
|
|
|
caps.commands = {
|
|
|
|
commands: [
|
|
|
|
"rust-analyzer.runSingle",
|
|
|
|
"rust-analyzer.debugSingle",
|
|
|
|
"rust-analyzer.showReferences",
|
|
|
|
"rust-analyzer.gotoLocation",
|
|
|
|
"editor.action.triggerParameterHints",
|
|
|
|
]
|
|
|
|
};
|
2020-05-17 18:53:55 -05:00
|
|
|
capabilities.experimental = caps;
|
2020-05-17 14:24:33 -05:00
|
|
|
}
|
|
|
|
initialize(_capabilities: lc.ServerCapabilities<any>, _documentSelector: lc.DocumentSelector | undefined): void {
|
|
|
|
}
|
2020-11-17 09:10:34 -06:00
|
|
|
dispose(): void {
|
|
|
|
}
|
2019-12-31 11:14:00 -06:00
|
|
|
}
|
2020-05-17 18:53:55 -05:00
|
|
|
|
2020-06-02 15:21:48 -05: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
|
|
|
}
|