6 files changed, 202 insertions, 50 deletions

diff --git a/editors/code/package.json b/editors/code/package.json
index d363e9fbb..a05a69752 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -27,6 +27,7 @@
     "scripts": {
         "vscode:prepublish": "tsc && rollup -c",
         "package": "vsce package -o rust-analyzer.vsix",
+        "build": "tsc",
         "watch": "tsc --watch",
         "lint": "tsfmt --verify && eslint -c .eslintrc.js --ext ts ./src",
         "fix": " tsfmt -r       && eslint -c .eslintrc.js --ext ts ./src --fix"
@@ -204,11 +205,6 @@
                     "default": [],
                     "description": "Paths to exclude from analysis."
                 },
-                "rust-analyzer.notifications.workspaceLoaded": {
-                    "type": "boolean",
-                    "default": true,
-                    "markdownDescription": "Whether to show `workspace loaded` message."
-                },
                 "rust-analyzer.notifications.cargoTomlNotFound": {
                     "type": "boolean",
                     "default": true,
@@ -293,7 +289,7 @@
                         "minItems": 1
                     },
                     "default": null,
-                    "markdownDescription": "Advanced option, fully override the command rust-analyzer uses for checking. The command should include `--message=format=json` or similar option."
+                    "markdownDescription": "Advanced option, fully override the command rust-analyzer uses for checking. The command should include `--message-format=json` or similar option."
                 },
                 "rust-analyzer.checkOnSave.allTargets": {
                     "type": "boolean",
@@ -396,6 +392,28 @@
                     "description": "Enable Proc macro support, cargo.loadOutDirsFromCheck must be enabled.",
                     "type": "boolean",
                     "default": false
+                },
+                "rust-analyzer.debug.engine": {
+                    "type": "string",
+                    "enum": [
+                        "auto",
+                        "vadimcn.vscode-lldb",
+                        "ms-vscode.cpptools"
+                    ],
+                    "default": "auto",
+                    "description": "Preffered debug engine.",
+                    "markdownEnumDescriptions": [
+                        "First try to use [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb), if it's not installed try to use [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools).",
+                        "Use [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb)",
+                        "Use [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cpptools)"
+                    ]
+                },
+                "rust-analyzer.debug.sourceFileMap": {
+                    "type": "object",
+                    "description": "Optional source file mappings passed to the debug engine.",
+                    "default": {
+                        "/rustc/<id>": "${env:USERPROFILE}/.rustup/toolchains/<toolchain-id>/lib/rustlib/src/rust"
+                    }
                 }
             }
         },
@@ -524,6 +542,10 @@
             {
                 "id": "unresolvedReference",
                 "description": "Style for names which can not be resolved due to compilation errors"
+            },
+            {
+                "id": "formatSpecifier",
+                "description": "Style for {} placeholders in format strings"
             }
         ],
         "semanticTokenModifiers": [
diff --git a/editors/code/src/cargo.ts b/editors/code/src/cargo.ts
new file mode 100644
index 000000000..a328ba9bd
--- /dev/null
+++ b/editors/code/src/cargo.ts
@@ -0,0 +1,106 @@
+import * as cp from 'child_process';
+import * as readline from 'readline';
+import { OutputChannel } from 'vscode';
+
+interface CompilationArtifact {
+    fileName: string;
+    name: string;
+    kind: string;
+    isTest: boolean;
+}
+
+export class Cargo {
+    rootFolder: string;
+    env?: Record<string, string>;
+    output: OutputChannel;
+
+    public constructor(cargoTomlFolder: string, output: OutputChannel, env: Record<string, string> | undefined = undefined) {
+        this.rootFolder = cargoTomlFolder;
+        this.output = output;
+        this.env = env;
+    }
+
+    public async artifactsFromArgs(cargoArgs: string[]): Promise<CompilationArtifact[]> {
+        const artifacts: CompilationArtifact[] = [];
+
+        try {
+            await this.runCargo(cargoArgs,
+                message => {
+                    if (message.reason === 'compiler-artifact' && message.executable) {
+                        const isBinary = message.target.crate_types.includes('bin');
+                        const isBuildScript = message.target.kind.includes('custom-build');
+                        if ((isBinary && !isBuildScript) || message.profile.test) {
+                            artifacts.push({
+                                fileName: message.executable,
+                                name: message.target.name,
+                                kind: message.target.kind[0],
+                                isTest: message.profile.test
+                            });
+                        }
+                    }
+                    else if (message.reason === 'compiler-message') {
+                        this.output.append(message.message.rendered);
+                    }
+                },
+                stderr => {
+                    this.output.append(stderr);
+                }
+            );
+        }
+        catch (err) {
+            this.output.show(true);
+            throw new Error(`Cargo invocation has failed: ${err}`);
+        }
+
+        return artifacts;
+    }
+
+    public async executableFromArgs(args: string[]): Promise<string> {
+        const cargoArgs = [...args]; // to remain  args unchanged
+        cargoArgs.push("--message-format=json");
+
+        const artifacts = await this.artifactsFromArgs(cargoArgs);
+
+        if (artifacts.length === 0) {
+            throw new Error('No compilation artifacts');
+        } else if (artifacts.length > 1) {
+            throw new Error('Multiple compilation artifacts are not supported.');
+        }
+
+        return artifacts[0].fileName;
+    }
+
+    runCargo(
+        cargoArgs: string[],
+        onStdoutJson: (obj: any) => void,
+        onStderrString: (data: string) => void
+    ): Promise<number> {
+        return new Promise<number>((resolve, reject) => {
+            const cargo = cp.spawn('cargo', cargoArgs, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                cwd: this.rootFolder,
+                env: this.env,
+            });
+
+            cargo.on('error', err => {
+                reject(new Error(`could not launch cargo: ${err}`));
+            });
+            cargo.stderr.on('data', chunk => {
+                onStderrString(chunk.toString());
+            });
+
+            const rl = readline.createInterface({ input: cargo.stdout });
+            rl.on('line', line => {
+                const message = JSON.parse(line);
+                onStdoutJson(message);
+            });
+
+            cargo.on('exit', (exitCode, _) => {
+                if (exitCode === 0)
+                    resolve(exitCode);
+                else
+                    reject(new Error(`exit code: ${exitCode}.`));
+            });
+        });
+    }
+}
\ No newline at end of file
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 0ad4b63ae..cffdcf11a 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -4,7 +4,7 @@ import * as vscode from 'vscode';
 import { CallHierarchyFeature } from 'vscode-languageclient/lib/callHierarchy.proposed';
 import { SemanticTokensFeature, DocumentSemanticsTokensSignature } from 'vscode-languageclient/lib/semanticTokens.proposed';
 
-export async function createClient(serverPath: string, cwd: string): Promise<lc.LanguageClient> {
+export function createClient(serverPath: string, cwd: string): lc.LanguageClient {
     // '.' Is the fallback if no folder is open
     // 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.
@@ -42,35 +42,6 @@ export async function createClient(serverPath: string, cwd: string): Promise<lc.
         clientOptions,
     );
 
-    // HACK: This is an awful way of filtering out the decorations notifications
-    // However, pending proper support, this is the most effecitve approach
-    // Proper support for this would entail a change to vscode-languageclient to allow not notifying on certain messages
-    // Or the ability to disable the serverside component of highlighting (but this means that to do tracing we need to disable hihlighting)
-    // This also requires considering our settings strategy, which is work which needs doing
-    // @ts-ignore The tracer is private to vscode-languageclient, but we need access to it to not log publishDecorations requests
-    res._tracer = {
-        log: (messageOrDataObject: string | unknown, data?: string) => {
-            if (typeof messageOrDataObject === 'string') {
-                if (
-                    messageOrDataObject.includes(
-                        'rust-analyzer/publishDecorations',
-                    ) ||
-                    messageOrDataObject.includes(
-                        'rust-analyzer/decorationsRequest',
-                    )
-                ) {
-                    // Don't log publish decorations requests
-                } else {
-                    // @ts-ignore This is just a utility function
-                    res.logTrace(messageOrDataObject, data);
-                }
-            } else {
-                // @ts-ignore
-                res.logObjectTrace(messageOrDataObject);
-            }
-        },
-    };
-
     // To turn on all proposed features use: res.registerProposedFeatures();
     // Here we want to enable CallHierarchyFeature and SemanticTokensFeature
     // since they are available on stable.
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
index 2635a1440..d77e8188c 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -1,8 +1,10 @@
 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';
 
 export function run(ctx: Ctx): Cmd {
     let prevRunnable: RunnableQuickPick | undefined;
@@ -62,25 +64,69 @@ export function runSingle(ctx: Ctx): Cmd {
     };
 }
 
+function getLldbDebugConfig(config: ra.Runnable, sourceFileMap: Record<string, string>): vscode.DebugConfiguration {
+    return {
+        type: "lldb",
+        request: "launch",
+        name: config.label,
+        cargo: {
+            args: config.args,
+        },
+        args: config.extraArgs,
+        cwd: config.cwd,
+        sourceMap: sourceFileMap
+    };
+}
+
+const debugOutput = vscode.window.createOutputChannel("Debug");
+
+async function getCppvsDebugConfig(config: ra.Runnable, sourceFileMap: Record<string, string>): Promise<vscode.DebugConfiguration> {
+    debugOutput.clear();
+
+    const cargo = new Cargo(config.cwd || '.', debugOutput);
+    const executable = await cargo.executableFromArgs(config.args);
+
+    // if we are here, there were no compilation errors.
+    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) => {
         const editor = ctx.activeRustEditor;
         if (!editor) return;
-        if (!vscode.extensions.getExtension("vadimcn.vscode-lldb")) {
-            vscode.window.showErrorMessage("Install `vadimcn.vscode-lldb` extension for debugging");
+
+        const lldbId = "vadimcn.vscode-lldb";
+        const cpptoolsId = "ms-vscode.cpptools";
+
+        const debugEngineId = ctx.config.debug.engine;
+        let debugEngine = null;
+        if (debugEngineId === "auto") {
+            debugEngine = vscode.extensions.getExtension(lldbId);
+            if (!debugEngine) {
+                debugEngine = vscode.extensions.getExtension(cpptoolsId);
+            }
+        }
+        else {
+            debugEngine = vscode.extensions.getExtension(debugEngineId);
+        }
+
+        if (!debugEngine) {
+            vscode.window.showErrorMessage(`Install [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=${lldbId})`
+                + ` or [MS C++ tools](https://marketplace.visualstudio.com/items?itemName=${cpptoolsId}) extension for debugging.`);
             return;
         }
 
-        const debugConfig = {
-            type: "lldb",
-            request: "launch",
-            name: config.label,
-            cargo: {
-                args: config.args,
-            },
-            args: config.extraArgs,
-            cwd: config.cwd
-        };
+        const debugConfig = lldbId === debugEngine.id
+            ? getLldbDebugConfig(config, ctx.config.debug.sourceFileMap)
+            : await getCppvsDebugConfig(config, ctx.config.debug.sourceFileMap);
 
         return vscode.debug.startDebugging(undefined, debugConfig);
     };
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 3b2eec8ba..110e54180 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -92,7 +92,6 @@ export class Config {
     get askBeforeDownload() { return this.get<boolean>("updates.askBeforeDownload"); }
     get traceExtension() { return this.get<boolean>("trace.extension"); }
 
-
     get inlayHints() {
         return {
             typeHints: this.get<boolean>("inlayHints.typeHints"),
@@ -107,4 +106,12 @@ export class Config {
             command: this.get<string>("checkOnSave.command"),
         };
     }
+
+    get debug() {
+        return {
+            engine: this.get<string>("debug.engine"),
+            sourceFileMap: this.get<Record<string, string>>("debug.sourceFileMap"),
+        };
+    }
+
 }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index f7ed62d03..41df11991 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -21,7 +21,7 @@ export class Ctx {
         serverPath: string,
         cwd: string,
     ): Promise<Ctx> {
-        const client = await createClient(serverPath, cwd);
+        const client = createClient(serverPath, cwd);
         const res = new Ctx(config, extCtx, client, serverPath);
         res.pushCleanup(client.start());
         await client.onReady();