constructor(ctx: Ctx) {

ctx.pushExtCleanup(

);

ctx.pushExtCleanup(vscode.languages.registerDefinitionProvider({ language: "rust" }, this));

vscode.workspace.onDidCloseTextDocument(

this.onDidCloseTextDocument,

this,

);

vscode.workspace.onDidChangeTextDocument(

this.onDidChangeTextDocument,

this,

);

vscode.window.onDidChangeVisibleTextEditors(

this.onDidChangeVisibleTextEditors,

this,

);

}

dispose() {

private findAstTextEditor(): undefined | vscode.TextEditor {

return vscode.window.visibleTextEditors.find(

);

}

// additional positional params are omitted

provideDefinition(

doc: vscode.TextDocument,

): vscode.ProviderResult<vscode.DefinitionLink[]> {

if (!this.rustEditor || doc.uri.toString() !== this.rustEditor.document.uri.toString()) {

return;

// additional positional params are omitted

provideHover(

doc: vscode.TextDocument,

): vscode.ProviderResult<vscode.Hover> {

if (!this.rustEditor) return;

private parseRustTextRange(

doc: vscode.TextDocument,

): undefined | vscode.Range {

const parsedRange = /(\d+)\.\.(\d+)/.exec(astLine);

if (!parsedRange) return;

export async function bootstrap(

context: vscode.ExtensionContext,

config: Config,

): Promise<string> {

const path = await getServer(context, config, state);

if (!path) {

throw new Error(

"Rust Analyzer Language Server is not available. " +

);

}

async function getServer(

context: vscode.ExtensionContext,

config: Config,

): Promise<string | undefined> {

const explicitPath = process.env["__RA_LSP_SERVER_DEBUG"] ?? config.serverPath;

if (explicitPath) {

const bundled = vscode.Uri.joinPath(context.extensionUri, "server", `rust-analyzer${ext}`);

const bundledExists = await vscode.workspace.fs.stat(bundled).then(

() => true,

);

if (bundledExists) {

let server = bundled;

const dest = vscode.Uri.joinPath(config.globalStorageUri, `rust-analyzer${ext}`);

let exists = await vscode.workspace.fs.stat(dest).then(

() => true,

);

if (exists && config.package.version !== state.serverVersion) {

await vscode.workspace.fs.delete(dest);

"run `cargo xtask install --server` to build the language server from sources. " +

"If you feel that your platform should be supported, please create an issue " +

"about that [here](https://github.com/rust-lang/rust-analyzer/issues) and we " +

);

return undefined;

}

} else {

resolve(stdout);

}

);

handle.stdin?.write(expression);

handle.stdin?.end();

} finally {

await vscode.workspace.fs.delete(origFile);

}

);

}

// 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.

function renderCommand(cmd: ra.CommandLink): string {

const commandId = randomUUID();

LINKED_COMMANDS.set(commandId, cmd);

return `[${cmd.title}](command:rust-analyzer.linkToCommand?${encodeURIComponent(

)} '${cmd.tooltip}')`;

}

.map(

(group) =>

(group.title ? group.title + " " : "") +

)

.join("___");

initializationOptions: vscode.WorkspaceConfiguration,

serverOptions: lc.ServerOptions,

config: Config,

): Promise<lc.LanguageClient> {

const clientOptions: lc.LanguageClientOptions = {

documentSelector: [{ scheme: "file", language: "rust" }],

async configuration(

params: lc.ConfigurationParams,

token: vscode.CancellationToken,

) {

const resp = await next(params, token);

if (resp && Array.isArray(resp)) {

async handleDiagnostics(

uri: vscode.Uri,

diagnosticList: vscode.Diagnostic[],

) {

const preview = config.previewRustcOutput;

const errorCode = config.useRustcErrorCode;

const folder = vscode.workspace.getWorkspaceFolder(uri)?.uri.fsPath;

if (folder) {

const parentBackslash = uri.fsPath.lastIndexOf(

);

const parent = uri.fsPath.substring(0, parentBackslash);

if (parent.startsWith(folder)) {

const path = vscode.Uri.file(

);

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",

);

switch (choice) {

case undefined:

config

.get<any[]>("linkedProjects")

?.concat(pathToInsert),

);

break;

case "Don't show this again":

await config.update(

"showUnlinkedFileNotification",

false,

);

break;

}

document: vscode.TextDocument,

position: vscode.Position,

token: vscode.CancellationToken,

) {

const editor = vscode.window.activeTextEditor;

const positionOrRange = editor?.selection?.contains(position)

client.code2ProtocolConverter.asTextDocumentIdentifier(document),

position: positionOrRange,

},

)

.then(

(result) => {

(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.

range: vscode.Range,

context: vscode.CodeActionContext,

token: vscode.CancellationToken,

) {

const params: lc.CodeActionParams = {

textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),

range: client.code2ProtocolConverter.asRange(range),

context: await client.code2ProtocolConverter.asCodeActionContext(

context,

),

};

return client.sendRequest(lc.CodeActionRequest.type, params, token).then(

if (lc.CodeAction.is(item)) {

assert(

!item.command,

);

const action = await client.protocol2CodeConverter.asCodeAction(

item,

);

result.push(action);

continue;

}

assert(

isCodeActionWithoutEditsAndCommands(item),

);

const kind = client.protocol2CodeConverter.asCodeActionKind(

);

const action = new vscode.CodeAction(item.title, kind);

const group = (item as any).group;

}

return result;

},

);

},

},

"rust-analyzer",

"Rust Analyzer Language Server",

serverOptions,

);

// To turn on all proposed features use: client.registerProposedFeatures();

}

initialize(

_capabilities: lc.ServerCapabilities,

): void {}

dispose(): void {}

}

}

initialize(

_capabilities: lc.ServerCapabilities,

): void {}

dispose(): void {}

}

})();

ctx.pushExtCleanup(

);

return async () => {

})();

ctx.pushExtCleanup(

);

return async () => {

const response = await client.sendRequest(ra.matchingBrace, {

textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),

positions: editor.selections.map((s) =>

),

});

editor.selections = editor.selections.map((sel, idx) => {

const lcEdits = await client

.sendRequest(ra.onEnter, {

textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(

),

position: client.code2ProtocolConverter.asPosition(editor.selection.active),

})

client,

uri,

position,

);

}

};

const position = editor.selection.active;

const selections = editor.selections;

const textDocument = client.code2ProtocolConverter.asTextDocumentIdentifier(

);

const options: vscode.InputBoxOptions = {

});

await vscode.workspace.applyEdit(

);

);

};

}

vscode.workspace.onDidChangeTextDocument(

this.onDidChangeTextDocument,

this,

);

vscode.window.onDidChangeActiveTextEditor(

this.onDidChangeActiveTextEditor,

this,

);

}

async provideTextDocumentContent(

uri: vscode.Uri,

): Promise<string> {

const rustEditor = ctx.activeRustEditor;

if (!rustEditor) return "";

ctx.pushExtCleanup(new AstInspector(ctx));

ctx.pushExtCleanup(

);

ctx.pushExtCleanup(

vscode.languages.setLanguageConfiguration("ra_syntax_tree", {

brackets: [["[", ")"]],

);

return async () => {

requestType: lc.RequestType<lc.TextDocumentPositionParams, string, void>,

uri: string,

scheme: string,

): Cmd {

const tdcp = new (class implements vscode.TextDocumentContentProvider {

readonly uri = vscode.Uri.parse(uri);

vscode.workspace.onDidChangeTextDocument(

this.onDidChangeTextDocument,

this,

);

vscode.window.onDidChangeActiveTextEditor(

this.onDidChangeActiveTextEditor,

this,

);

}

async provideTextDocumentContent(

_uri: vscode.Uri,

): Promise<string> {

const rustEditor = ctx.activeRustEditor;

if (!rustEditor) return "";

const client = ctx.client;

const params = {

textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(

),

position: client.code2ProtocolConverter.asPosition(rustEditor.selection.active),

};

ra.interpretFunction,

uri,

`rust-analyzer-interpret-function`,

);

}

vscode.workspace.onDidChangeTextDocument(

this.onDidChangeTextDocument,

this,

);

vscode.window.onDidChangeActiveTextEditor(

this.onDidChangeActiveTextEditor,

this,

);

}

async provideTextDocumentContent(

_uri: vscode.Uri,

): Promise<string> {

const rustEditor = ctx.activeRustEditor;

if (!rustEditor) return "";

const client = ctx.client;

const params = client.code2ProtocolConverter.asTextDocumentIdentifier(

);

return client.sendRequest(ra.viewFileText, params, ct);

}

})();

ctx.pushExtCleanup(

);

return async () => {

vscode.workspace.onDidChangeTextDocument(

this.onDidChangeTextDocument,

this,

);

vscode.window.onDidChangeActiveTextEditor(

this.onDidChangeActiveTextEditor,

this,

);

}

async provideTextDocumentContent(

_uri: vscode.Uri,

): Promise<string> {

const rustEditor = ctx.activeRustEditor;

if (!rustEditor) return "";

const params = {

textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(

),

};

return client.sendRequest(ra.viewItemTree, params, ct);

})();

ctx.pushExtCleanup(

);

return async () => {

enableScripts: true,

retainContextWhenHidden: true,

localResourceRoots: [nodeModulesPath],

);

const params = {

full: full,

const expanded = await client.sendRequest(ra.expandMacro, {

textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(

),

position,

});

})();

ctx.pushExtCleanup(

);

return async () => {

return discoverWorkspace([file], discoverProjectCommand, {

cwd: path.dirname(file.uri.fsPath),

});

);

ctx.addToDiscoveredWorkspaces(workspaces);

client: LanguageClient | undefined,

uri: string,

position: lc.Position,

) {

if (client) {

await vscode.commands.executeCommand(

"editor.action.showReferences",

vscode.Uri.parse(uri),

client.protocol2CodeConverter.asPosition(position),

);

}

}

if (!selectedAction) return;

await vscode.commands.executeCommand(

"rust-analyzer.resolveCodeAction",

);

};

}

documentChanges: itemEdit.documentChanges?.filter((change) => "kind" in change),

};

const fileSystemEdit = await client.protocol2CodeConverter.asWorkspaceEdit(

);

await vscode.workspace.applyEdit(fileSystemEdit);

await applySnippetWorkspaceEdit(edit);

const locations: lc.Location[] = tests.map((it) =>

lc.Location.create(

it.runnable.location!.targetUri,

);

await showReferencesImpl(client, uri, position, locations);

);

};

}

"memory_layout",

"[Memory Layout]",

vscode.ViewColumn.Two,

);

document.webview.html = `<!DOCTYPE html>

vscode.workspace.onDidChangeConfiguration(

this.onDidChangeConfiguration,

this,

);

this.refreshLogging();

this.configureLanguage();

this.configureLanguage();

const requiresReloadOpt = this.requiresReloadOpts.find((opt) =>

);

if (!requiresReloadOpt) return;

Object.entries(extraEnv).map(([k, v]) => [

k,

typeof v !== "string" ? v.toString() : v,

);

}

get traceExtension() {

// to interact with.

export function prepareVSCodeConfig<T>(

resp: T,

): T {

if (Is.string(resp)) {

return substituteVSCodeVariableInString(resp) as T;

}

}

return [`env:${key}`, { deps: [...deps], value }];

);

const resolved = new Set<string>();

if (varName in supportedVariables) {

const fn = expectNotUndefined(

supportedVariables[varName],

);

return fn();

} else {

export function fetchWorkspace(): Workspace {

const folders = (vscode.workspace.workspaceFolders || []).filter(

);

const rustDocuments = vscode.workspace.textDocuments.filter((document) =>

);

return folders.length === 0

export async function discoverWorkspace(

files: readonly vscode.TextDocument[],

command: string[],

): Promise<JsonProject> {

const paths = files.map((f) => `"${f.uri.fsPath}"`).join(" ");

const joinedCommand = command.join(" ");

constructor(

readonly extCtx: vscode.ExtensionContext,

commandFactories: Record<string, CommandFactory>,

) {

extCtx.subscriptions.push(this);

this.statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);

log.error("Bootstrap error", err);

throw new Error(message);

);

const newEnv = Object.assign({}, process.env, this.config.serverExtraEnv);

const run: lc.Executable = {

return discoverWorkspace([file], discoverProjectCommand, {

cwd: path.dirname(file.uri.fsPath),

});

);

this.addToDiscoveredWorkspaces(workspaces);

if (key === "linkedProjects" && this.config.discoveredWorkspaces.length > 0) {

obj["linkedProjects"] = this.config.discoveredWorkspaces;

}

);

this._client = await createClient(

initializationOptions,

serverOptions,

this.config,

);

this.pushClientCleanup(

this._client.onNotification(ra.serverStatus, (params) =>

);

this.pushClientCleanup(

this._client.onNotification(ra.openServerLogs, () => {

this.outputChannel!.show();

);

}

return this._client;

} else {

callback = () =>

vscode.window.showErrorMessage(

);

}

}

statusBar.color = new vscode.ThemeColor("statusBarItem.warningForeground");

statusBar.backgroundColor = new vscode.ThemeColor(

);

statusBar.command = "rust-analyzer.openLogs";

icon = "$(warning) ";

case "stopped":

statusBar.tooltip.appendText("Server is stopped");

statusBar.tooltip.appendMarkdown(

);

statusBar.color = undefined;

statusBar.backgroundColor = undefined;

}

statusBar.tooltip.appendMarkdown("\n\n[Open logs](command:rust-analyzer.openLogs)");

statusBar.tooltip.appendMarkdown(

);

statusBar.tooltip.appendMarkdown(

);

statusBar.tooltip.appendMarkdown(

);

statusBar.tooltip.appendMarkdown("\n\n[Stop server](command:rust-analyzer.stopServer)");

if (!status.quiescent) icon = "$(sync~spin) ";

config: ra.Runnable,

executable: string,

env: Record<string, string>,

) => vscode.DebugConfiguration;

export async function makeDebugConfig(ctx: Ctx, runnable: ra.Runnable): Promise<void> {

const answer = await vscode.window.showErrorMessage(

`Launch configuration '${debugConfig.name}' already exists!`,

"Cancel",

);

if (answer === "Cancel") return;

async function getDebugConfiguration(

ctx: Ctx,

): Promise<vscode.DebugConfiguration | undefined> {

const editor = ctx.activeRustEditor;

if (!editor) return;

if (!debugEngine) {

await vscode.window.showErrorMessage(

`Install [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)` +

);

return;

}

async function getDebugExecutable(

runnable: ra.Runnable,

): Promise<string> {

const cargo = new Cargo(runnable.args.workspaceRoot || ".", debugOutput, env);

const executable = await cargo.executableFromArgs(runnable.args.cargoArgs);

runnable: ra.Runnable,

executable: string,

env: Record<string, string>,

): vscode.DebugConfiguration {

return {

type: "lldb",

runnable: ra.Runnable,

executable: string,

env: Record<string, string>,

): vscode.DebugConfiguration {

return {

type: os.platform() === "win32" ? "cppvsdbg" : "cppdbg",

}

getParent?(

): vscode.ProviderResult<Dependency | DependencyFile> {

if (element instanceof Dependency) return undefined;

return element.parent;

}

getChildren(

): vscode.ProviderResult<Dependency[] | DependencyFile[]> {

return new Promise((resolve, _reject) => {

if (!vscode.workspace.workspaceFolders) {

private async getRootDependencies(): Promise<Dependency[]> {

const dependenciesResult: FetchDependencyListResult = await this.ctx.client.sendRequest(

ra.fetchDependencyList,

);

const crates = dependenciesResult.crates;

moduleName,

version,

vscode.Uri.parse(path).fsPath,

);

}

}

public override readonly label: string,

private version: string,

readonly dependencyPath: string,

) {

super(label, collapsibleState);

this.resourceUri = vscode.Uri.file(dependencyPath);

override readonly label: string,

readonly dependencyPath: string,

readonly parent: Dependency | DependencyFile,

) {

super(vscode.Uri.file(dependencyPath), collapsibleState);

this.id = this.resourceUri!.fsPath.toLowerCase();

}

private _getDecorations(

): ProviderResult<[TextEditorDecorationType, Range[]][]> {

const stringContents = getRenderedDiagnostic(this.ctx, uri);

const lines = stringContents.split("\n");

lineNumber,

offset - totalEscapeLength,

lineNumber,

);

offset += content.length;

private static _convertColor(

color?: string,

): ThemeColor | string | undefined {

if (!color) {

return undefined;

// rust-analyzer extensions

export const analyzerStatus = new lc.RequestType<AnalyzerStatusParams, string, void>(

);

export const cancelFlycheck = new lc.NotificationType0("rust-analyzer/cancelFlycheck");

export const clearFlycheck = new lc.NotificationType0("rust-analyzer/clearFlycheck");

export const expandMacro = new lc.RequestType<ExpandMacroParams, ExpandedMacro | null, void>(

);

export const memoryUsage = new lc.RequestType0<string, void>("rust-analyzer/memoryUsage");

export const openServerLogs = new lc.NotificationType0("rust-analyzer/openServerLogs");

export const relatedTests = new lc.RequestType<lc.TextDocumentPositionParams, TestInfo[], void>(

);

export const reloadWorkspace = new lc.RequestType0<null, void>("rust-analyzer/reloadWorkspace");

export const rebuildProcMacros = new lc.RequestType0<null, void>("rust-analyzer/rebuildProcMacros");

}>("rust-analyzer/runFlycheck");

export const shuffleCrateGraph = new lc.RequestType0<null, void>("rust-analyzer/shuffleCrateGraph");

export const syntaxTree = new lc.RequestType<SyntaxTreeParams, string, void>(

);

export const viewCrateGraph = new lc.RequestType<ViewCrateGraphParams, string, void>(

);

export const viewFileText = new lc.RequestType<lc.TextDocumentIdentifier, string, void>(

);

export const viewHir = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(

);

export const viewMir = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(

);

export const interpretFunction = new lc.RequestType<lc.TextDocumentPositionParams, string, void>(

);

export const viewItemTree = new lc.RequestType<ViewItemTreeParams, string, void>(

);

export type AnalyzerStatusParams = { textDocument?: lc.TextDocumentIdentifier };

// experimental extensions

export const joinLines = new lc.RequestType<JoinLinesParams, lc.TextEdit[], void>(

);

export const matchingBrace = new lc.RequestType<MatchingBraceParams, lc.Position[], void>(

);

export const moveItem = new lc.RequestType<MoveItemParams, lc.TextEdit[], void>(

);

export const onEnter = new lc.RequestType<lc.TextDocumentPositionParams, lc.TextEdit[], void>(

);

export const openCargoToml = new lc.RequestType<OpenCargoTomlParams, lc.Location, void>(

);

export const openDocs = new lc.RequestType<lc.TextDocumentPositionParams, string | void, void>(

);

export const parentModule = new lc.RequestType<

lc.TextDocumentPositionParams,

void

>("experimental/parentModule");

export const runnables = new lc.RequestType<RunnablesParams, Runnable[], void>(

);

export const serverStatus = new lc.NotificationType<ServerStatusParams>(

);

export const ssr = new lc.RequestType<SsrParams, lc.WorkspaceEdit, void>("experimental/ssr");

export const viewRecursiveMemoryLayout = new lc.RequestType<

}

export async function activate(

): Promise<RustAnalyzerExtensionApi> {

if (vscode.extensions.getExtension("rust-lang.rust")) {

vscode.window

`You have both the rust-analyzer (rust-lang.rust-analyzer) and Rust (rust-lang.rust) ` +

"plugins enabled. These are known to conflict and cause various functions of " +

"both plugins to not work correctly. You should disable one of them.",

)

.then(() => {}, console.error);

}

// so we do it ourselves.

const api = await activateServer(ctx).catch((err) => {

void vscode.window.showErrorMessage(

);

throw err;

});

ctx.pushExtCleanup(

vscode.workspace.registerTextDocumentContentProvider(

diagnostics.URI_SCHEME,

);

const decorationProvider = new diagnostics.AnsiDecorationProvider(ctx);

vscode.workspace.onDidChangeTextDocument(

async (event) => await decorateVisibleEditors(event.document),

null,

);

vscode.workspace.onDidOpenTextDocument(decorateVisibleEditors, null, ctx.subscriptions);

vscode.window.onDidChangeActiveTextEditor(

}

},

null,

);

vscode.window.onDidChangeVisibleTextEditors(

async (visibleEditors) => {

}

},

null,

);

vscode.workspace.onDidChangeWorkspaceFolders(

async (_) => ctx.onWorkspaceFolderChanges(),

null,

);

vscode.workspace.onDidChangeConfiguration(

async (_) => {

});

},

null,

);

await ctx.start();

ctx: CtxInit,

prevRunnable?: RunnableQuickPick,

debuggeeOnly = false,

): Promise<RunnableQuickPick | undefined> {

const editor = ctx.activeRustEditor;

if (!editor) return;

}

}

}),

);

quickPick.show();

});

export function prepareEnv(

runnable: ra.Runnable,

): Record<string, string> {

const env: Record<string, string> = { RUST_BACKTRACE: "short" };

args,

config.problemMatcher,

config.cargoRunner,

);

cargoTask.presentationOptions.clear = true;

for (const indel of edits) {

assert(

!parseSnippet(indel.newText),

);

builder.replace(indel.range, indel.newText);

}

await vscode.window.showTextDocument(uri, {});

}

return vscode.window.visibleTextEditors.find(

);

}

selections.push(

new vscode.Selection(

new vscode.Position(startLine, startColumn),

);

builder.replace(indel.range, newText);

} else {

`cargo ${def.command}`,

[def.command],

this.config.problemMatcher,

);

vscodeTask.group = def.group;

tasks.push(vscodeTask);

task.name,

args,

this.config.problemMatcher,

);

}

args: string[],

problemMatcher: string[],

customRunner?: string,

): Promise<vscode.Task> {

let exec: vscode.ProcessExecution | vscode.ShellExecution | undefined = undefined;

name,

TASK_SOURCE,

exec,

);

}

constructor(

readonly rootFolder: string,

readonly output: vscode.OutputChannel,

) {}

// Made public for testing purposes

this.output.append(message.message.rendered);

}

},

);

} catch (err) {

this.output.show(true);

private async runCargo(

cargoArgs: string[],

onStdoutJson: (obj: any) => void,

): Promise<number> {

const path = await cargoPath();

return await new Promise((resolve, reject) => {

if (await isFileAtUri(standardPath)) return standardPath.fsPath;

}

return executableName;

);

async function lookupInPath(exec: string): Promise<boolean> {

* underlying async function.

*/

export function memoizeAsync<Ret, TThis, Param extends string>(

) {

const cache = new Map<string, Ret>();

const context = new Context();

const testFiles = (await readdir(path.resolve(__dirname))).filter((name) =>

);

for (const testFile of testFiles) {

try {