Merge #4448

4448: Generate configuration for launch.json r=vsrs a=vsrs

This PR adds two new commands: `"rust-analyzer.debug"` and `"rust-analyzer.newDebugConfig"`. The former is a supplement to the existing `"rust-analyzer.run"` command and works the same way: asks for a runnable and starts new debug session. The latter allows adding a new configuration to **launch.json** (or to update an existing one).

If the new option `"rust-analyzer.debug.useLaunchJson"` is set to true then `"rust-analyzer.debug"` and Debug Lens will first look for existing debug configuration in **launch.json**. That is, it has become possible to specify startup arguments, env variables, etc.

`"rust-analyzer.debug.useLaunchJson"` is false by default, but it might be worth making true the default value. Personally I prefer true, but I'm not sure if it is good for all value.

----
I think that this PR also solves https://github.com/rust-analyzer/rust-analyzer/issues/3441.
Both methods to update launch.json mentioned in the issue do not work:
1. Menu. It is only possible to add a launch.json configuration template via a debug adapter. And anyway it's only a template and it is impossible to specify arguments from an extension.

2. DebugConfigurationProvider. The exact opposite situation: it is possible to specify all debug session settings, but it is impossible to export these settings to launch.json.

Separate `"rust-analyzer.newDebugConfig"` command looks better for me.

----
Fixes #4450
Fixes #3441

Co-authored-by: vsrs <[email protected]>
Co-authored-by: vsrs <[email protected]>

6 files changed, 254 insertions, 100 deletions

diff --git a/editors/code/package.json b/editors/code/package.json
index b8a2182f0..4e7e3faf7 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -121,6 +121,16 @@
                 "category": "Rust Analyzer"
             },
             {
+                "command": "rust-analyzer.debug",
+                "title": "Debug",
+                "category": "Rust Analyzer"
+            },
+            {
+                "command": "rust-analyzer.newDebugConfig",
+                "title": "Generate launch configuration",
+                "category": "Rust Analyzer"
+            },
+            {
                 "command": "rust-analyzer.analyzerStatus",
                 "title": "Status",
                 "category": "Rust Analyzer"
diff --git a/editors/code/src/cargo.ts b/editors/code/src/cargo.ts
index 2a2c2e0e1..28c7de992 100644
--- a/editors/code/src/cargo.ts
+++ b/editors/code/src/cargo.ts
@@ -49,7 +49,20 @@ export class Cargo {
     async executableFromArgs(args: readonly string[]): Promise<string> {
         const cargoArgs = [...args, "--message-format=json"];
 
-        const artifacts = await this.artifactsFromArgs(cargoArgs);
+        // arguments for a runnable from the quick pick should be updated.
+        // see crates\rust-analyzer\src\main_loop\handlers.rs, handle_code_lens
+        if (cargoArgs[0] === "run") {
+            cargoArgs[0] = "build";
+        } else if (cargoArgs.indexOf("--no-run") === -1) {
+            cargoArgs.push("--no-run");
+        }
+
+        let artifacts = await this.artifactsFromArgs(cargoArgs);
+        if (cargoArgs[0] === "test") {
+            // for instance, `crates\rust-analyzer\tests\heavy_tests\main.rs` tests
+            // produce 2 artifacts: {"kind": "bin"} and {"kind": "test"}
+            artifacts = artifacts.filter(a => a.isTest);
+        }
 
         if (artifacts.length === 0) {
             throw new Error('No compilation artifacts');
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
index ae328d2a4..b1d93fc34 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -1,43 +1,82 @@
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 import * as ra from '../rust-analyzer-api';
-import * as os from "os";
 
 import { Ctx, Cmd } from '../ctx';
-import { Cargo } from '../cargo';
+import { startDebugSession, getDebugConfiguration } from '../debug';
 
-export function run(ctx: Ctx): Cmd {
-    let prevRunnable: RunnableQuickPick | undefined;
+const quickPickButtons = [{ iconPath: new vscode.ThemeIcon("save"), tooltip: "Save as a launch.json configurtation." }];
 
-    return async () => {
-        const editor = ctx.activeRustEditor;
-        const client = ctx.client;
-        if (!editor || !client) return;
+async function selectRunnable(ctx: Ctx, prevRunnable?: RunnableQuickPick, showButtons: boolean = true): Promise<RunnableQuickPick | undefined> {
+    const editor = ctx.activeRustEditor;
+    const client = ctx.client;
+    if (!editor || !client) return;
 
-        const textDocument: lc.TextDocumentIdentifier = {
-            uri: editor.document.uri.toString(),
-        };
+    const textDocument: lc.TextDocumentIdentifier = {
+        uri: editor.document.uri.toString(),
+    };
 
-        const runnables = await client.sendRequest(ra.runnables, {
-            textDocument,
-            position: client.code2ProtocolConverter.asPosition(
-                editor.selection.active,
-            ),
-        });
-        const items: RunnableQuickPick[] = [];
-        if (prevRunnable) {
-            items.push(prevRunnable);
+    const runnables = await client.sendRequest(ra.runnables, {
+        textDocument,
+        position: client.code2ProtocolConverter.asPosition(
+            editor.selection.active,
+        ),
+    });
+    const items: RunnableQuickPick[] = [];
+    if (prevRunnable) {
+        items.push(prevRunnable);
+    }
+    for (const r of runnables) {
+        if (
+            prevRunnable &&
+            JSON.stringify(prevRunnable.runnable) === JSON.stringify(r)
+        ) {
+            continue;
         }
-        for (const r of runnables) {
-            if (
-                prevRunnable &&
-                JSON.stringify(prevRunnable.runnable) === JSON.stringify(r)
-            ) {
-                continue;
-            }
-            items.push(new RunnableQuickPick(r));
+        items.push(new RunnableQuickPick(r));
+    }
+
+    return await new Promise((resolve) => {
+        const disposables: vscode.Disposable[] = [];
+        const close = (result?: RunnableQuickPick) => {
+            resolve(result);
+            disposables.forEach(d => d.dispose());
+        };
+
+        const quickPick = vscode.window.createQuickPick<RunnableQuickPick>();
+        quickPick.items = items;
+        quickPick.title = "Select Runnable";
+        if (showButtons) {
+            quickPick.buttons = quickPickButtons;
         }
-        const item = await vscode.window.showQuickPick(items);
+        disposables.push(
+            quickPick.onDidHide(() => close()),
+            quickPick.onDidAccept(() => close(quickPick.selectedItems[0])),
+            quickPick.onDidTriggerButton((_button) => {
+                (async () => await makeDebugConfig(ctx, quickPick.activeItems[0]))();
+                close();
+            }),
+            quickPick.onDidChangeActive((active) => {
+                if (showButtons && active.length > 0) {
+                    if (active[0].label.startsWith('cargo')) {
+                        // save button makes no sense for `cargo test` or `cargo check`
+                        quickPick.buttons = [];
+                    } else if (quickPick.buttons.length === 0) {
+                        quickPick.buttons = quickPickButtons;
+                    }
+                }
+            }),
+            quickPick
+        );
+        quickPick.show();
+    });
+}
+
+export function run(ctx: Ctx): Cmd {
+    let prevRunnable: RunnableQuickPick | undefined;
+
+    return async () => {
+        const item = await selectRunnable(ctx, prevRunnable);
         if (!item) return;
 
         item.detail = 'rerun';
@@ -64,88 +103,54 @@ export function runSingle(ctx: Ctx): Cmd {
     };
 }
 
-function getLldbDebugConfig(config: ra.Runnable, executable: string, sourceFileMap?: Record<string, string>): vscode.DebugConfiguration {
-    return {
-        type: "lldb",
-        request: "launch",
-        name: config.label,
-        program: executable,
-        args: config.extraArgs,
-        cwd: config.cwd,
-        sourceMap: sourceFileMap,
-        sourceLanguages: ["rust"]
+export function debug(ctx: Ctx): Cmd {
+    let prevDebuggee: RunnableQuickPick | undefined;
+
+    return async () => {
+        const item = await selectRunnable(ctx, prevDebuggee);
+        if (!item) return;
+
+        item.detail = 'restart';
+        prevDebuggee = item;
+        return await startDebugSession(ctx, item.runnable);
     };
 }
 
-function getCppvsDebugConfig(config: ra.Runnable, executable: string, sourceFileMap?: Record<string, string>): vscode.DebugConfiguration {
-    return {
-        type: (os.platform() === "win32") ? "cppvsdbg" : 'cppdbg',
-        request: "launch",
-        name: config.label,
-        program: executable,
-        args: config.extraArgs,
-        cwd: config.cwd,
-        sourceFileMap: sourceFileMap,
+export function debugSingle(ctx: Ctx): Cmd {
+    return async (config: ra.Runnable) => {
+        await startDebugSession(ctx, config);
     };
 }
 
-const debugOutput = vscode.window.createOutputChannel("Debug");
-
-async function getDebugExecutable(config: ra.Runnable): Promise<string> {
-    const cargo = new Cargo(config.cwd || '.', debugOutput);
-    const executable = await cargo.executableFromArgs(config.args);
-
-    // if we are here, there were no compilation errors.
-    return executable;
-}
+async function makeDebugConfig(ctx: Ctx, item: RunnableQuickPick): Promise<void> {
+    const scope = ctx.activeRustEditor?.document.uri;
+    if (!scope) return;
 
-type DebugConfigProvider = (config: ra.Runnable, executable: string, sourceFileMap?: Record<string, string>) => vscode.DebugConfiguration;
+    const debugConfig = await getDebugConfiguration(ctx, item.runnable);
+    if (!debugConfig) return;
 
-export function debugSingle(ctx: Ctx): Cmd {
-    return async (config: ra.Runnable) => {
-        const editor = ctx.activeRustEditor;
-        if (!editor) return;
+    const wsLaunchSection = vscode.workspace.getConfiguration("launch", scope);
+    const configurations = wsLaunchSection.get<any[]>("configurations") || [];
 
-        const knownEngines: Record<string, DebugConfigProvider> = {
-            "vadimcn.vscode-lldb": getLldbDebugConfig,
-            "ms-vscode.cpptools": getCppvsDebugConfig
-        };
-        const debugOptions = ctx.config.debug;
-
-        let debugEngine = null;
-        if (debugOptions.engine === "auto") {
-            for (var engineId in knownEngines) {
-                debugEngine = vscode.extensions.getExtension(engineId);
-                if (debugEngine) break;
-            }
-        }
-        else {
-            debugEngine = vscode.extensions.getExtension(debugOptions.engine);
-        }
+    const index = configurations.findIndex(c => c.name === debugConfig.name);
+    if (index !== -1) {
+        const answer = await vscode.window.showErrorMessage(`Launch configuration '${debugConfig.name}' already exists!`, 'Cancel', 'Update');
+        if (answer === "Cancel") return;
 
-        if (!debugEngine) {
-            vscode.window.showErrorMessage(`Install [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)`
-                + ` or [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools) extension for debugging.`);
-            return;
-        }
+        configurations[index] = debugConfig;
+    } else {
+        configurations.push(debugConfig);
+    }
 
-        debugOutput.clear();
-        if (ctx.config.debug.openUpDebugPane) {
-            debugOutput.show(true);
-        }
+    await wsLaunchSection.update("configurations", configurations);
+}
 
-        const executable = await getDebugExecutable(config);
-        const debugConfig = knownEngines[debugEngine.id](config, executable, debugOptions.sourceFileMap);
-        if (debugConfig.type in debugOptions.engineSettings) {
-            const settingsMap = (debugOptions.engineSettings as any)[debugConfig.type];
-            for (var key in settingsMap) {
-                debugConfig[key] = settingsMap[key];
-            }
-        }
+export function newDebugConfig(ctx: Ctx): Cmd {
+    return async () => {
+        const item = await selectRunnable(ctx, undefined, false);
+        if (!item) return;
 
-        debugOutput.appendLine("Launching debug configuration:");
-        debugOutput.appendLine(JSON.stringify(debugConfig, null, 2));
-        return vscode.debug.startDebugging(undefined, debugConfig);
+        await makeDebugConfig(ctx, item);
     };
 }
 
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index be2e27aec..1652827c3 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -116,7 +116,7 @@ export class Config {
             engine: this.get<string>("debug.engine"),
             engineSettings: this.get<object>("debug.engineSettings"),
             openUpDebugPane: this.get<boolean>("debug.openUpDebugPane"),
-            sourceFileMap: sourceFileMap,
+            sourceFileMap: sourceFileMap
         };
     }
 }
diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts
new file mode 100644
index 000000000..d3fe588e8
--- /dev/null
+++ b/editors/code/src/debug.ts
@@ -0,0 +1,124 @@
+import * as os from "os";
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as ra from './rust-analyzer-api';
+
+import { Cargo } from './cargo';
+import { Ctx } from "./ctx";
+
+const debugOutput = vscode.window.createOutputChannel("Debug");
+type DebugConfigProvider = (config: ra.Runnable, executable: string, sourceFileMap?: Record<string, string>) => vscode.DebugConfiguration;
+
+function getLldbDebugConfig(config: ra.Runnable, executable: string, sourceFileMap?: Record<string, string>): vscode.DebugConfiguration {
+    return {
+        type: "lldb",
+        request: "launch",
+        name: config.label,
+        program: executable,
+        args: config.extraArgs,
+        cwd: config.cwd,
+        sourceMap: sourceFileMap,
+        sourceLanguages: ["rust"]
+    };
+}
+
+function getCppvsDebugConfig(config: ra.Runnable, executable: string, sourceFileMap?: Record<string, string>): vscode.DebugConfiguration {
+    return {
+        type: (os.platform() === "win32") ? "cppvsdbg" : "cppdbg",
+        request: "launch",
+        name: config.label,
+        program: executable,
+        args: config.extraArgs,
+        cwd: config.cwd,
+        sourceFileMap: sourceFileMap,
+    };
+}
+
+async function getDebugExecutable(config: ra.Runnable): Promise<string> {
+    const cargo = new Cargo(config.cwd || '.', debugOutput);
+    const executable = await cargo.executableFromArgs(config.args);
+
+    // if we are here, there were no compilation errors.
+    return executable;
+}
+
+export async function getDebugConfiguration(ctx: Ctx, config: ra.Runnable): Promise<vscode.DebugConfiguration | undefined> {
+    const editor = ctx.activeRustEditor;
+    if (!editor) return;
+
+    const knownEngines: Record<string, DebugConfigProvider> = {
+        "vadimcn.vscode-lldb": getLldbDebugConfig,
+        "ms-vscode.cpptools": getCppvsDebugConfig
+    };
+    const debugOptions = ctx.config.debug;
+
+    let debugEngine = null;
+    if (debugOptions.engine === "auto") {
+        for (var engineId in knownEngines) {
+            debugEngine = vscode.extensions.getExtension(engineId);
+            if (debugEngine) break;
+        }
+    } else {
+        debugEngine = vscode.extensions.getExtension(debugOptions.engine);
+    }
+
+    if (!debugEngine) {
+        vscode.window.showErrorMessage(`Install [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)`
+            + ` or [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools) extension for debugging.`);
+        return;
+    }
+
+    debugOutput.clear();
+    if (ctx.config.debug.openUpDebugPane) {
+        debugOutput.show(true);
+    }
+
+    const wsFolder = path.normalize(vscode.workspace.workspaceFolders![0].uri.fsPath); // folder exists or RA is not active.
+    function simplifyPath(p: string): string {
+        return path.normalize(p).replace(wsFolder, '${workspaceRoot}');
+    }
+
+    const executable = await getDebugExecutable(config);
+    const debugConfig = knownEngines[debugEngine.id](config, simplifyPath(executable), debugOptions.sourceFileMap);
+    if (debugConfig.type in debugOptions.engineSettings) {
+        const settingsMap = (debugOptions.engineSettings as any)[debugConfig.type];
+        for (var key in settingsMap) {
+            debugConfig[key] = settingsMap[key];
+        }
+    }
+
+    if (debugConfig.name === "run binary") {
+        // The LSP side: crates\rust-analyzer\src\main_loop\handlers.rs,
+        // fn to_lsp_runnable(...) with RunnableKind::Bin
+        debugConfig.name = `run ${path.basename(executable)}`;
+    }
+
+    if (debugConfig.cwd) {
+        debugConfig.cwd = simplifyPath(debugConfig.cwd);
+    }
+
+    return debugConfig;
+}
+
+export async function startDebugSession(ctx: Ctx, config: ra.Runnable): Promise<boolean> {
+    let debugConfig: vscode.DebugConfiguration | undefined = undefined;
+    let message = "";
+
+    const wsLaunchSection = vscode.workspace.getConfiguration("launch");
+    const configurations = wsLaunchSection.get<any[]>("configurations") || [];
+
+    const index = configurations.findIndex(c => c.name === config.label);
+    if (-1 !== index) {
+        debugConfig = configurations[index];
+        message = " (from launch.json)";
+        debugOutput.clear();
+    } else {
+        debugConfig = await getDebugConfiguration(ctx, config);
+    }
+
+    if (!debugConfig) return false;
+
+    debugOutput.appendLine(`Launching debug configuration${message}:`);
+    debugOutput.appendLine(JSON.stringify(debugConfig, null, 2));
+    return vscode.debug.startDebugging(undefined, debugConfig);
+}
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 9b020d001..c015460b8 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -77,6 +77,8 @@ export async function activate(context: vscode.ExtensionContext) {
     ctx.registerCommand('syntaxTree', commands.syntaxTree);
     ctx.registerCommand('expandMacro', commands.expandMacro);
     ctx.registerCommand('run', commands.run);
+    ctx.registerCommand('debug', commands.debug);
+    ctx.registerCommand('newDebugConfig', commands.newDebugConfig);
 
     defaultOnEnter.dispose();
     ctx.registerCommand('onEnter', commands.onEnter);