diff --git a/editors/code/src/ast_inspector.ts b/editors/code/src/ast_inspector.ts index 688c53a9b1..35b705c477 100644 --- a/editors/code/src/ast_inspector.ts +++ b/editors/code/src/ast_inspector.ts @@ -1,8 +1,7 @@ import * as vscode from "vscode"; import type { Ctx, Disposable } from "./ctx"; -import { type RustEditor, isRustEditor } from "./util"; -import { unwrapUndefinable } from "./undefinable"; +import { type RustEditor, isRustEditor, unwrapUndefinable } from "./util"; // FIXME: consider implementing this via the Tree View API? // https://code.visualstudio.com/api/extension-guides/tree-view diff --git a/editors/code/src/bootstrap.ts b/editors/code/src/bootstrap.ts index 6cf399599d..5a92b285ae 100644 --- a/editors/code/src/bootstrap.ts +++ b/editors/code/src/bootstrap.ts @@ -1,9 +1,9 @@ import * as vscode from "vscode"; import * as os from "os"; import type { Config } from "./config"; -import { log, isValidExecutable } from "./util"; +import { type Env, log } from "./util"; import type { PersistentState } from "./persistent_state"; -import { exec } from "child_process"; +import { exec, spawnSync } from "child_process"; export async function bootstrap( context: vscode.ExtensionContext, @@ -13,7 +13,7 @@ export async function bootstrap( const path = await getServer(context, config, state); if (!path) { throw new Error( - "Rust Analyzer Language Server is not available. " + + "rust-analyzer Language Server is not available. " + "Please, ensure its [proper installation](https://rust-analyzer.github.io/manual.html#installation).", ); } @@ -21,12 +21,12 @@ export async function bootstrap( log.info("Using server binary at", path); if (!isValidExecutable(path, config.serverExtraEnv)) { - if (config.serverPath) { - throw new Error(`Failed to execute ${path} --version. \`config.server.path\` or \`config.serverPath\` has been set explicitly.\ - Consider removing this config or making a valid server binary available at that path.`); - } else { - throw new Error(`Failed to execute ${path} --version`); - } + throw new Error( + `Failed to execute ${path} --version.` + config.serverPath + ? `\`config.server.path\` or \`config.serverPath\` has been set explicitly.\ + Consider removing this config or making a valid server binary available at that path.` + : "", + ); } return path; @@ -54,27 +54,12 @@ async function getServer( if (bundledExists) { let server = bundled; if (await isNixOs()) { - await vscode.workspace.fs.createDirectory(config.globalStorageUri).then(); - const dest = vscode.Uri.joinPath(config.globalStorageUri, `rust-analyzer${ext}`); - let exists = await vscode.workspace.fs.stat(dest).then( - () => true, - () => false, - ); - if (exists && config.package.version !== state.serverVersion) { - await vscode.workspace.fs.delete(dest); - exists = false; - } - if (!exists) { - await vscode.workspace.fs.copy(bundled, dest); - await patchelf(dest); - } - server = dest; + server = await getNixOsServer(config, ext, state, bundled, server); + await state.updateServerVersion(config.package.version); } - await state.updateServerVersion(config.package.version); return server.fsPath; } - await state.updateServerVersion(undefined); await vscode.window.showErrorMessage( "Unfortunately we don't ship binaries for your platform yet. " + "You need to manually clone the rust-analyzer repository and " + @@ -86,6 +71,45 @@ async function getServer( return undefined; } +export function isValidExecutable(path: string, extraEnv: Env): boolean { + log.debug("Checking availability of a binary at", path); + + const res = spawnSync(path, ["--version"], { + encoding: "utf8", + env: { ...process.env, ...extraEnv }, + }); + + const printOutput = res.error ? log.warn : log.info; + printOutput(path, "--version:", res); + + return res.status === 0; +} + +async function getNixOsServer( + config: Config, + ext: string, + state: PersistentState, + bundled: vscode.Uri, + server: vscode.Uri, +) { + await vscode.workspace.fs.createDirectory(config.globalStorageUri).then(); + const dest = vscode.Uri.joinPath(config.globalStorageUri, `rust-analyzer${ext}`); + let exists = await vscode.workspace.fs.stat(dest).then( + () => true, + () => false, + ); + if (exists && config.package.version !== state.serverVersion) { + await vscode.workspace.fs.delete(dest); + exists = false; + } + if (!exists) { + await vscode.workspace.fs.copy(bundled, dest); + await patchelf(dest); + } + server = dest; + return server; +} + async function isNixOs(): Promise { try { const contents = ( diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts index f679c88398..1c2a34b484 100644 --- a/editors/code/src/client.ts +++ b/editors/code/src/client.ts @@ -3,73 +3,13 @@ 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 { assert, unwrapUndefinable } from "./util"; import * as diagnostics from "./diagnostics"; import { WorkspaceEdit } from "vscode"; import { type Config, prepareVSCodeConfig } from "./config"; -import { randomUUID } from "crypto"; import { sep as pathSeparator } from "path"; -import { unwrapUndefinable } from "./undefinable"; import { RaLanguageClient } from "./lang_client"; -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(); - -// 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]), - )} '${cmd.tooltip}')`; -} - -function renderHoverActions(actions: ra.CommandLinkGroup[]): vscode.MarkdownString { - 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( traceOutputChannel: vscode.OutputChannel, outputChannel: vscode.OutputChannel, @@ -450,3 +390,32 @@ function isCodeActionWithoutEditsAndCommands(value: any): boolean { candidate.command === void 0 ); } + +// 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 | undefined = undefined; + +function renderCommand(cmd: ra.CommandLink): string { + HOVER_REFERENCE_COMMAND = cmd; + return `[${cmd.title}](command:rust-analyzer.hoverRefCommandProxy '${cmd.tooltip}')`; +} + +function renderHoverActions(actions: ra.CommandLinkGroup[]): vscode.MarkdownString { + 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; +} diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts index 5048f820e4..c226aefeab 100644 --- a/editors/code/src/commands.ts +++ b/editors/code/src/commands.ts @@ -24,12 +24,12 @@ import { isRustEditor, type RustEditor, type RustDocument, + unwrapUndefinable, } from "./util"; import { startDebugSession, makeDebugConfig } from "./debug"; import type { LanguageClient } from "vscode-languageclient/node"; -import { LINKED_COMMANDS } from "./client"; +import { HOVER_REFERENCE_COMMAND } from "./client"; import type { DependencyId } from "./dependencies_provider"; -import { unwrapUndefinable } from "./undefinable"; import { log } from "./util"; export * from "./ast_inspector"; @@ -1196,11 +1196,10 @@ export function newDebugConfig(ctx: CtxInit): Cmd { }; } -export function linkToCommand(_: Ctx): Cmd { - return async (commandId: string) => { - const link = LINKED_COMMANDS.get(commandId); - if (link) { - const { command, arguments: args = [] } = link; +export function hoverRefCommandProxy(_: Ctx): Cmd { + return async () => { + if (HOVER_REFERENCE_COMMAND) { + const { command, arguments: args = [] } = HOVER_REFERENCE_COMMAND; await vscode.commands.executeCommand(command, ...args); } }; diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts index e676bc0826..1931cfe381 100644 --- a/editors/code/src/config.ts +++ b/editors/code/src/config.ts @@ -2,9 +2,7 @@ import * as Is from "vscode-languageclient/lib/common/utils/is"; import * as os from "os"; import * as path from "path"; import * as vscode from "vscode"; -import type { Env } from "./client"; -import { log } from "./util"; -import { expectNotUndefined, unwrapUndefinable } from "./undefinable"; +import { type Env, log, unwrapUndefinable, expectNotUndefined } from "./util"; import type { JsonProject } from "./rust_project"; export type RunnableEnvCfgItem = { diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts index eef2f6f4ee..58fe1df51f 100644 --- a/editors/code/src/debug.ts +++ b/editors/code/src/debug.ts @@ -6,8 +6,7 @@ import type * as ra from "./lsp_ext"; import { Cargo, getRustcId, getSysroot } from "./toolchain"; import type { Ctx } from "./ctx"; import { prepareEnv } from "./run"; -import { unwrapUndefinable } from "./undefinable"; -import { isCargoRunnableArgs } from "./util"; +import { isCargoRunnableArgs, unwrapUndefinable } from "./util"; const debugOutput = vscode.window.createOutputChannel("Debug"); type DebugConfigProvider = ( @@ -136,7 +135,7 @@ async function getDebugConfiguration( const workspaceQualifier = isMultiFolderWorkspace ? `:${workspace.name}` : ""; function simplifyPath(p: string): string { // see https://github.com/rust-lang/rust-analyzer/pull/5513#issuecomment-663458818 for why this is needed - return path.normalize(p).replace(wsFolder, "${workspaceFolder" + workspaceQualifier + "}"); + return path.normalize(p).replace(wsFolder, `\${workspaceFolder${workspaceQualifier}}`); } const env = prepareEnv(runnable.label, runnableArgs, ctx.config.runnablesExtraEnv); diff --git a/editors/code/src/dependencies_provider.ts b/editors/code/src/dependencies_provider.ts index 863ace0780..203ef5cc85 100644 --- a/editors/code/src/dependencies_provider.ts +++ b/editors/code/src/dependencies_provider.ts @@ -4,7 +4,7 @@ import * as fs from "fs"; import type { CtxInit } from "./ctx"; import * as ra from "./lsp_ext"; import type { FetchDependencyListResult } from "./lsp_ext"; -import { unwrapUndefinable } from "./undefinable"; +import { unwrapUndefinable } from "./util"; export class RustDependenciesProvider implements vscode.TreeDataProvider diff --git a/editors/code/src/diagnostics.ts b/editors/code/src/diagnostics.ts index e31a1cdcef..9fb2993d12 100644 --- a/editors/code/src/diagnostics.ts +++ b/editors/code/src/diagnostics.ts @@ -8,7 +8,7 @@ import { window, } from "vscode"; import type { Ctx } from "./ctx"; -import { unwrapUndefinable } from "./undefinable"; +import { unwrapUndefinable } from "./util"; export const URI_SCHEME = "rust-analyzer-diagnostics-view"; diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts index 0af58fd781..788f9a0c14 100644 --- a/editors/code/src/main.ts +++ b/editors/code/src/main.ts @@ -182,7 +182,7 @@ function createCommands(): Record { applySnippetWorkspaceEdit: { enabled: commands.applySnippetWorkspaceEditCommand }, debugSingle: { enabled: commands.debugSingle }, gotoLocation: { enabled: commands.gotoLocation }, - linkToCommand: { enabled: commands.linkToCommand }, + hoverRefCommandProxy: { enabled: commands.hoverRefCommandProxy }, resolveCodeAction: { enabled: commands.resolveCodeAction }, runSingle: { enabled: commands.runSingle }, showReferences: { enabled: commands.showReferences }, diff --git a/editors/code/src/nullable.ts b/editors/code/src/nullable.ts deleted file mode 100644 index e973e16290..0000000000 --- a/editors/code/src/nullable.ts +++ /dev/null @@ -1,19 +0,0 @@ -export type NotNull = T extends null ? never : T; - -export type Nullable = T | null; - -function isNotNull(input: Nullable): input is NotNull { - return input !== null; -} - -function expectNotNull(input: Nullable, msg: string): NotNull { - if (isNotNull(input)) { - return input; - } - - throw new TypeError(msg); -} - -export function unwrapNullable(input: Nullable): NotNull { - return expectNotNull(input, `unwrapping \`null\``); -} diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts index 1206137b6f..7a9049af0d 100644 --- a/editors/code/src/run.ts +++ b/editors/code/src/run.ts @@ -6,9 +6,8 @@ import * as tasks from "./tasks"; import type { CtxInit } from "./ctx"; import { makeDebugConfig } from "./debug"; import type { Config, RunnableEnvCfg, RunnableEnvCfgItem } from "./config"; -import { unwrapUndefinable } from "./undefinable"; import type { LanguageClient } from "vscode-languageclient/node"; -import type { RustEditor } from "./util"; +import { unwrapUndefinable, type RustEditor } from "./util"; import * as toolchain from "./toolchain"; const quickPickButtons = [ @@ -148,8 +147,7 @@ export async function createTaskFromRunnable( }; } - // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion - const target = vscode.workspace.workspaceFolders![0]; // safe, see main activate() + const target = vscode.workspace.workspaceFolders?.[0]; const exec = await tasks.targetToExecution(definition, config.cargoRunner, true); const task = await tasks.buildRustTask( target, diff --git a/editors/code/src/snippets.ts b/editors/code/src/snippets.ts index b3982bdf2b..a469a9cd1f 100644 --- a/editors/code/src/snippets.ts +++ b/editors/code/src/snippets.ts @@ -1,7 +1,6 @@ import * as vscode from "vscode"; -import { assert } from "./util"; -import { unwrapUndefinable } from "./undefinable"; +import { assert, unwrapUndefinable } from "./util"; export type SnippetTextDocumentEdit = [vscode.Uri, (vscode.TextEdit | vscode.SnippetTextEdit)[]]; diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts index 870b1ffb71..6f4fbf9188 100644 --- a/editors/code/src/tasks.ts +++ b/editors/code/src/tasks.ts @@ -1,7 +1,6 @@ import * as vscode from "vscode"; import type { Config } from "./config"; -import { log } from "./util"; -import { unwrapUndefinable } from "./undefinable"; +import { log, unwrapUndefinable } from "./util"; import * as toolchain from "./toolchain"; // This ends up as the `type` key in tasks.json. RLS also uses `cargo` and diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts index 060b0245d2..a48d2d90cc 100644 --- a/editors/code/src/toolchain.ts +++ b/editors/code/src/toolchain.ts @@ -3,9 +3,7 @@ import * as os from "os"; import * as path from "path"; import * as readline from "readline"; import * as vscode from "vscode"; -import { execute, log, memoizeAsync } from "./util"; -import { unwrapNullable } from "./nullable"; -import { unwrapUndefinable } from "./undefinable"; +import { execute, log, memoizeAsync, unwrapNullable, unwrapUndefinable } from "./util"; interface CompilationArtifact { fileName: string; @@ -157,7 +155,7 @@ export function cargoPath(): Promise { } /** Mirrors `toolchain::get_path_for_executable()` implementation */ -export const getPathForExecutable = memoizeAsync( +const getPathForExecutable = memoizeAsync( // We apply caching to decrease file-system interactions async (executableName: "cargo" | "rustc" | "rustup"): Promise => { { diff --git a/editors/code/src/undefinable.ts b/editors/code/src/undefinable.ts deleted file mode 100644 index 813bac5a12..0000000000 --- a/editors/code/src/undefinable.ts +++ /dev/null @@ -1,19 +0,0 @@ -export type NotUndefined = T extends undefined ? never : T; - -export type Undefinable = T | undefined; - -function isNotUndefined(input: Undefinable): input is NotUndefined { - return input !== undefined; -} - -export function expectNotUndefined(input: Undefinable, msg: string): NotUndefined { - if (isNotUndefined(input)) { - return input; - } - - throw new TypeError(msg); -} - -export function unwrapUndefinable(input: Undefinable): NotUndefined { - return expectNotUndefined(input, `unwrapping \`undefined\``); -} diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts index 868cb2b780..dd1cbe38ff 100644 --- a/editors/code/src/util.ts +++ b/editors/code/src/util.ts @@ -1,9 +1,8 @@ import * as vscode from "vscode"; import { strict as nativeAssert } from "assert"; -import { exec, type ExecOptions, spawnSync } from "child_process"; +import { exec, type ExecOptions } from "child_process"; import { inspect } from "util"; import type { CargoRunnableArgs, ShellRunnableArgs } from "./lsp_ext"; -import type { Env } from "./client"; export function assert(condition: boolean, explanation: string): asserts condition { try { @@ -14,6 +13,10 @@ export function assert(condition: boolean, explanation: string): asserts conditi } } +export type Env = { + [name: string]: string; +}; + export const log = new (class { private enabled = true; private readonly output = vscode.window.createOutputChannel("Rust Analyzer Client"); @@ -101,20 +104,6 @@ export function isDocumentInWorkspace(document: RustDocument): boolean { return false; } -export function isValidExecutable(path: string, extraEnv: Env): boolean { - log.debug("Checking availability of a binary at", path); - - const res = spawnSync(path, ["--version"], { - encoding: "utf8", - env: { ...process.env, ...extraEnv }, - }); - - const printOutput = res.error ? log.warn : log.info; - printOutput(path, "--version:", res); - - return res.status === 0; -} - /** Sets ['when'](https://code.visualstudio.com/docs/getstarted/keybindings#_when-clause-contexts) clause contexts */ export function setContextValue(key: string, value: any): Thenable { return vscode.commands.executeCommand("setContext", key, value); @@ -206,3 +195,42 @@ export class LazyOutputChannel implements vscode.OutputChannel { } } } + +export type NotNull = T extends null ? never : T; + +export type Nullable = T | null; + +function isNotNull(input: Nullable): input is NotNull { + return input !== null; +} + +function expectNotNull(input: Nullable, msg: string): NotNull { + if (isNotNull(input)) { + return input; + } + + throw new TypeError(msg); +} + +export function unwrapNullable(input: Nullable): NotNull { + return expectNotNull(input, `unwrapping \`null\``); +} +export type NotUndefined = T extends undefined ? never : T; + +export type Undefinable = T | undefined; + +function isNotUndefined(input: Undefinable): input is NotUndefined { + return input !== undefined; +} + +export function expectNotUndefined(input: Undefinable, msg: string): NotUndefined { + if (isNotUndefined(input)) { + return input; + } + + throw new TypeError(msg); +} + +export function unwrapUndefinable(input: Undefinable): NotUndefined { + return expectNotUndefined(input, `unwrapping \`undefined\``); +}