7 files changed, 109 insertions, 35 deletions

diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 1a0805bd3..4092435db 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -148,34 +148,16 @@ export function moveItem(ctx: Ctx, direction: ra.Direction): Cmd {
         const client = ctx.client;
         if (!editor || !client) return;
 
-        const edit = await client.sendRequest(ra.moveItem, {
+        const lcEdits = await client.sendRequest(ra.moveItem, {
             range: client.code2ProtocolConverter.asRange(editor.selection),
             textDocument: ctx.client.code2ProtocolConverter.asTextDocumentIdentifier(editor.document),
             direction
         });
 
-        if (!edit) return;
+        if (!lcEdits) return;
 
-        let cursor: vscode.Position | null = null;
-
-        await editor.edit((builder) => {
-            client.protocol2CodeConverter.asTextEdits(edit.edits).forEach((edit: any) => {
-                builder.replace(edit.range, edit.newText);
-
-                if (direction === ra.Direction.Up) {
-                    if (!cursor || edit.range.end.isBeforeOrEqual(cursor)) {
-                        cursor = edit.range.end;
-                    }
-                } else {
-                    if (!cursor || edit.range.end.isAfterOrEqual(cursor)) {
-                        cursor = edit.range.end;
-                    }
-                }
-            });
-        }).then(() => {
-            const newPosition = cursor ?? editor.selection.start;
-            editor.selection = new vscode.Selection(newPosition, newPosition);
-        });
+        const edits = client.protocol2CodeConverter.asTextEdits(lcEdits);
+        await applySnippetTextEdits(editor, edits);
     };
 }
 
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 82f0a0566..e858f80bc 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -115,6 +115,7 @@ export class Config {
             typeHints: this.get<boolean>("inlayHints.typeHints"),
             parameterHints: this.get<boolean>("inlayHints.parameterHints"),
             chainingHints: this.get<boolean>("inlayHints.chainingHints"),
+            smallerHints: this.get<boolean>("inlayHints.smallerHints"),
             maxLength: this.get<null | number>("inlayHints.maxLength"),
         };
     }
@@ -134,8 +135,12 @@ export class Config {
     }
 
     get debug() {
-        // "/rustc/<id>" used by suggestions only.
-        const { ["/rustc/<id>"]: _, ...sourceFileMap } = this.get<Record<string, string>>("debug.sourceFileMap");
+        let sourceFileMap = this.get<Record<string, string> | "auto">("debug.sourceFileMap");
+        if (sourceFileMap !== "auto") {
+            // "/rustc/<id>" used by suggestions only.
+            const { ["/rustc/<id>"]: _, ...trimmed } = this.get<Record<string, string>>("debug.sourceFileMap");
+            sourceFileMap = trimmed;
+        }
 
         return {
             engine: this.get<string>("debug.engine"),
diff --git a/editors/code/src/debug.ts b/editors/code/src/debug.ts
index 3889a2773..830980f96 100644
--- a/editors/code/src/debug.ts
+++ b/editors/code/src/debug.ts
@@ -3,7 +3,7 @@ import * as vscode from 'vscode';
 import * as path from 'path';
 import * as ra from './lsp_ext';
 
-import { Cargo } from './toolchain';
+import { Cargo, getRustcId, getSysroot } from './toolchain';
 import { Ctx } from "./ctx";
 import { prepareEnv } from "./run";
 
@@ -104,7 +104,17 @@ async function getDebugConfiguration(ctx: Ctx, runnable: ra.Runnable): Promise<v
 
     const executable = await getDebugExecutable(runnable);
     const env = prepareEnv(runnable, ctx.config.runnableEnv);
-    const debugConfig = knownEngines[debugEngine.id](runnable, simplifyPath(executable), env, debugOptions.sourceFileMap);
+    let sourceFileMap = debugOptions.sourceFileMap;
+    if (sourceFileMap === "auto") {
+        // let's try to use the default toolchain
+        const commitHash = await getRustcId(wsFolder);
+        const sysroot = await getSysroot(wsFolder);
+        const rustlib = path.normalize(sysroot + "/lib/rustlib/src/rust");
+        sourceFileMap = {};
+        sourceFileMap[`/rustc/${commitHash}/`] = rustlib;
+    }
+
+    const debugConfig = knownEngines[debugEngine.id](runnable, simplifyPath(executable), env, sourceFileMap);
     if (debugConfig.type in debugOptions.engineSettings) {
         const settingsMap = (debugOptions.engineSettings as any)[debugConfig.type];
         for (var key in settingsMap) {
diff --git a/editors/code/src/inlay_hints.ts b/editors/code/src/inlay_hints.ts
index 61db6b8d0..c23d6f738 100644
--- a/editors/code/src/inlay_hints.ts
+++ b/editors/code/src/inlay_hints.ts
@@ -5,6 +5,17 @@ import * as ra from './lsp_ext';
 import { Ctx, Disposable } from './ctx';
 import { sendRequestWithRetry, isRustDocument, RustDocument, RustEditor, sleep } from './util';
 
+interface InlayHintStyle {
+    decorationType: vscode.TextEditorDecorationType;
+    toDecoration(hint: ra.InlayHint, conv: lc.Protocol2CodeConverter): vscode.DecorationOptions;
+};
+
+interface InlayHintsStyles {
+    typeHints: InlayHintStyle;
+    paramHints: InlayHintStyle;
+    chainingHints: InlayHintStyle;
+}
+
 
 export function activateInlayHints(ctx: Ctx) {
     const maybeUpdater = {
@@ -19,6 +30,7 @@ export function activateInlayHints(ctx: Ctx) {
 
             await sleep(100);
             if (this.updater) {
+                this.updater.updateInlayHintsStyles();
                 this.updater.syncCacheAndRenderHints();
             } else {
                 this.updater = new HintsUpdater(ctx);
@@ -39,11 +51,7 @@ export function activateInlayHints(ctx: Ctx) {
     maybeUpdater.onConfigChange().catch(console.error);
 }
 
-const typeHints = createHintStyle("type");
-const paramHints = createHintStyle("parameter");
-const chainingHints = createHintStyle("chaining");
-
-function createHintStyle(hintKind: "type" | "parameter" | "chaining") {
+function createHintStyle(hintKind: "type" | "parameter" | "chaining", smallerHints: boolean): InlayHintStyle {
     // U+200C is a zero-width non-joiner to prevent the editor from forming a ligature
     // between code and type hints
     const [pos, render] = ({
@@ -61,7 +69,7 @@ function createHintStyle(hintKind: "type" | "parameter" | "chaining") {
                 backgroundColor: bg,
                 fontStyle: "normal",
                 fontWeight: "normal",
-                textDecoration: ";font-size:smaller",
+                textDecoration: smallerHints ? ";font-size:smaller" : "none",
             },
         }),
         toDecoration(hint: ra.InlayHint, conv: lc.Protocol2CodeConverter): vscode.DecorationOptions {
@@ -73,9 +81,23 @@ function createHintStyle(hintKind: "type" | "parameter" | "chaining") {
     };
 }
 
+const smallHintsStyles = {
+    typeHints: createHintStyle("type", true),
+    paramHints: createHintStyle("parameter", true),
+    chainingHints: createHintStyle("chaining", true),
+};
+
+const biggerHintsStyles = {
+    typeHints: createHintStyle("type", false),
+    paramHints: createHintStyle("parameter", false),
+    chainingHints: createHintStyle("chaining", false),
+};
+
 class HintsUpdater implements Disposable {
     private sourceFiles = new Map<string, RustSourceFile>(); // map Uri -> RustSourceFile
     private readonly disposables: Disposable[] = [];
+    private pendingDisposeDecorations: undefined | InlayHintsStyles = undefined;
+    private inlayHintsStyles!: InlayHintsStyles;
 
     constructor(private readonly ctx: Ctx) {
         vscode.window.onDidChangeVisibleTextEditors(
@@ -100,6 +122,7 @@ class HintsUpdater implements Disposable {
             }
         ));
 
+        this.updateInlayHintsStyles();
         this.syncCacheAndRenderHints();
     }
 
@@ -114,6 +137,15 @@ class HintsUpdater implements Disposable {
         this.syncCacheAndRenderHints();
     }
 
+    updateInlayHintsStyles() {
+        const inlayHintsStyles = this.ctx.config.inlayHints.smallerHints ? smallHintsStyles : biggerHintsStyles;
+
+        if (inlayHintsStyles !== this.inlayHintsStyles) {
+            this.pendingDisposeDecorations = this.inlayHintsStyles;
+            this.inlayHintsStyles = inlayHintsStyles;
+        }
+    }
+
     syncCacheAndRenderHints() {
         this.sourceFiles.forEach((file, uri) => this.fetchHints(file).then(hints => {
             if (!hints) return;
@@ -161,12 +193,20 @@ class HintsUpdater implements Disposable {
     }
 
     private renderDecorations(editor: RustEditor, decorations: InlaysDecorations) {
+        const { typeHints, paramHints, chainingHints } = this.inlayHintsStyles;
+        if (this.pendingDisposeDecorations !== undefined) {
+            const { typeHints, paramHints, chainingHints } = this.pendingDisposeDecorations;
+            editor.setDecorations(typeHints.decorationType, []);
+            editor.setDecorations(paramHints.decorationType, []);
+            editor.setDecorations(chainingHints.decorationType, []);
+        }
         editor.setDecorations(typeHints.decorationType, decorations.type);
         editor.setDecorations(paramHints.decorationType, decorations.param);
         editor.setDecorations(chainingHints.decorationType, decorations.chaining);
     }
 
     private hintsToDecorations(hints: ra.InlayHint[]): InlaysDecorations {
+        const { typeHints, paramHints, chainingHints } = this.inlayHintsStyles;
         const decorations: InlaysDecorations = { type: [], param: [], chaining: [] };
         const conv = this.ctx.client.protocol2CodeConverter;
 
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index e453bb9e0..f78de894b 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -129,7 +129,7 @@ export interface OpenCargoTomlParams {
     textDocument: lc.TextDocumentIdentifier;
 }
 
-export const moveItem = new lc.RequestType<MoveItemParams, lc.TextDocumentEdit | void, void>("experimental/moveItem");
+export const moveItem = new lc.RequestType<MoveItemParams, lc.TextEdit[], void>("experimental/moveItem");
 
 export interface MoveItemParams {
     textDocument: lc.TextDocumentIdentifier;
diff --git a/editors/code/src/toolchain.ts b/editors/code/src/toolchain.ts
index a5dc3cf0c..68826c478 100644
--- a/editors/code/src/toolchain.ts
+++ b/editors/code/src/toolchain.ts
@@ -4,7 +4,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import * as readline from 'readline';
 import { OutputChannel } from 'vscode';
-import { log, memoize } from './util';
+import { execute, log, memoize } from './util';
 
 interface CompilationArtifact {
     fileName: string;
@@ -121,6 +121,24 @@ export class Cargo {
     }
 }
 
+/** Mirrors `project_model::sysroot::discover_sysroot_dir()` implementation*/
+export function getSysroot(dir: string): Promise<string> {
+    const rustcPath = getPathForExecutable("rustc");
+
+    // do not memoize the result because the toolchain may change between runs
+    return execute(`${rustcPath} --print sysroot`, { cwd: dir });
+}
+
+export async function getRustcId(dir: string): Promise<string> {
+    const rustcPath = getPathForExecutable("rustc");
+
+    // do not memoize the result because the toolchain may change between runs
+    const data = await execute(`${rustcPath} -V -v`, { cwd: dir });
+    const rx = /commit-hash:\s(.*)$/m.compile();
+
+    return rx.exec(data)![1];
+}
+
 /** Mirrors `toolchain::cargo()` implementation */
 export function cargoPath(): string {
     return getPathForExecutable("cargo");
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 53492a445..56e0e439e 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -1,7 +1,7 @@
 import * as lc from "vscode-languageclient/node";
 import * as vscode from "vscode";
 import { strict as nativeAssert } from "assert";
-import { spawnSync } from "child_process";
+import { exec, ExecOptions, spawnSync } from "child_process";
 import { inspect } from "util";
 
 export function assert(condition: boolean, explanation: string): asserts condition {
@@ -141,3 +141,22 @@ export function memoize<Ret, TThis, Param extends string>(func: (this: TThis, ar
         return result;
     };
 }
+
+/** Awaitable wrapper around `child_process.exec` */
+export function execute(command: string, options: ExecOptions): Promise<string> {
+    return new Promise((resolve, reject) => {
+        exec(command, options, (err, stdout, stderr) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+
+            if (stderr) {
+                reject(new Error(stderr));
+                return;
+            }
+
+            resolve(stdout.trimEnd());
+        });
+    });
+}