11 files changed, 287 insertions, 374 deletions

diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index 98f2f232f..3b1d00bca 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -5,15 +5,14 @@ import { Config } from './config';
 import { CallHierarchyFeature } from 'vscode-languageclient/lib/callHierarchy.proposed';
 import { SemanticTokensFeature, DocumentSemanticsTokensSignature } from 'vscode-languageclient/lib/semanticTokens.proposed';
 
-export async function createClient(config: Config, serverPath: string): Promise<lc.LanguageClient> {
+export async function createClient(config: Config, serverPath: string, cwd: string): Promise<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.
-    const workspaceFolderPath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? '.';
 
     const run: lc.Executable = {
         command: serverPath,
-        options: { cwd: workspaceFolderPath },
+        options: { cwd },
     };
     const serverOptions: lc.ServerOptions = {
         run,
@@ -22,32 +21,10 @@ export async function createClient(config: Config, serverPath: string): Promise<
     const traceOutputChannel = vscode.window.createOutputChannel(
         'Rust Analyzer Language Server Trace',
     );
-    const cargoWatchOpts = config.cargoWatchOptions;
 
     const clientOptions: lc.LanguageClientOptions = {
         documentSelector: [{ scheme: 'file', language: 'rust' }],
-        initializationOptions: {
-            publishDecorations: !config.highlightingSemanticTokens,
-            lruCapacity: config.lruCapacity,
-
-            inlayHintsType: config.inlayHints.typeHints,
-            inlayHintsParameter: config.inlayHints.parameterHints,
-            inlayHintsChaining: config.inlayHints.chainingHints,
-            inlayHintsMaxLength: config.inlayHints.maxLength,
-
-            cargoWatchEnable: cargoWatchOpts.enable,
-            cargoWatchArgs: cargoWatchOpts.arguments,
-            cargoWatchCommand: cargoWatchOpts.command,
-            cargoWatchAllTargets: cargoWatchOpts.allTargets,
-
-            excludeGlobs: config.excludeGlobs,
-            useClientWatching: config.useClientWatching,
-            featureFlags: config.featureFlags,
-            withSysroot: config.withSysroot,
-            cargoFeatures: config.cargoFeatures,
-            rustfmtArgs: config.rustfmtArgs,
-            vscodeLldb: vscode.extensions.getExtension("vadimcn.vscode-lldb") != null,
-        },
+        initializationOptions: vscode.workspace.getConfiguration("rust-analyzer"),
         traceOutputChannel,
         middleware: {
             // Workaround for https://github.com/microsoft/vscode-languageserver-node/issues/576
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
index 357155163..2635a1440 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -66,6 +66,10 @@ 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");
+            return;
+        }
 
         const debugConfig = {
             type: "lldb",
diff --git a/editors/code/src/commands/syntax_tree.ts b/editors/code/src/commands/syntax_tree.ts
index 2e08e8f11..b7a397414 100644
--- a/editors/code/src/commands/syntax_tree.ts
+++ b/editors/code/src/commands/syntax_tree.ts
@@ -1,8 +1,10 @@
 import * as vscode from 'vscode';
 import * as ra from '../rust-analyzer-api';
 
-import { Ctx, Cmd } from '../ctx';
-import { isRustDocument } from '../util';
+import { Ctx, Cmd, Disposable } from '../ctx';
+import { isRustDocument, RustEditor, isRustEditor, sleep } from '../util';
+
+const AST_FILE_SCHEME = "rust-analyzer";
 
 // Opens the virtual file that will show the syntax tree
 //
@@ -10,35 +12,16 @@ import { isRustDocument } from '../util';
 export function syntaxTree(ctx: Ctx): Cmd {
     const tdcp = new TextDocumentContentProvider(ctx);
 
-    ctx.pushCleanup(
-        vscode.workspace.registerTextDocumentContentProvider(
-            'rust-analyzer',
-            tdcp,
-        ),
-    );
-
-    vscode.workspace.onDidChangeTextDocument(
-        (event: vscode.TextDocumentChangeEvent) => {
-            const doc = event.document;
-            if (!isRustDocument(doc)) return;
-            afterLs(() => tdcp.eventEmitter.fire(tdcp.uri));
-        },
-        null,
-        ctx.subscriptions,
-    );
-
-    vscode.window.onDidChangeActiveTextEditor(
-        (editor: vscode.TextEditor | undefined) => {
-            if (!editor || !isRustDocument(editor.document)) return;
-            tdcp.eventEmitter.fire(tdcp.uri);
-        },
-        null,
-        ctx.subscriptions,
-    );
+    void new AstInspector(ctx);
+
+    ctx.pushCleanup(vscode.workspace.registerTextDocumentContentProvider(AST_FILE_SCHEME, tdcp));
+    ctx.pushCleanup(vscode.languages.setLanguageConfiguration("ra_syntax_tree", {
+        brackets: [["[", ")"]],
+    }));
 
     return async () => {
         const editor = vscode.window.activeTextEditor;
-        const rangeEnabled = !!(editor && !editor.selection.isEmpty);
+        const rangeEnabled = !!editor && !editor.selection.isEmpty;
 
         const uri = rangeEnabled
             ? vscode.Uri.parse(`${tdcp.uri.toString()}?range=true`)
@@ -48,45 +31,200 @@ export function syntaxTree(ctx: Ctx): Cmd {
 
         tdcp.eventEmitter.fire(uri);
 
-        return vscode.window.showTextDocument(
-            document,
-            vscode.ViewColumn.Two,
-            true,
-        );
+        void await vscode.window.showTextDocument(document, {
+            viewColumn: vscode.ViewColumn.Two,
+            preserveFocus: true
+        });
     };
 }
 
-// We need to order this after LS updates, but there's no API for that.
-// Hence, good old setTimeout.
-function afterLs(f: () => void) {
-    setTimeout(f, 10);
-}
-
-
 class TextDocumentContentProvider implements vscode.TextDocumentContentProvider {
-    uri = vscode.Uri.parse('rust-analyzer://syntaxtree');
-    eventEmitter = new vscode.EventEmitter<vscode.Uri>();
+    readonly uri = vscode.Uri.parse('rust-analyzer://syntaxtree/tree.rast');
+    readonly eventEmitter = new vscode.EventEmitter<vscode.Uri>();
+
 
     constructor(private readonly ctx: Ctx) {
+        vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, ctx.subscriptions);
+        vscode.window.onDidChangeActiveTextEditor(this.onDidChangeActiveTextEditor, this, ctx.subscriptions);
     }
 
-    provideTextDocumentContent(uri: vscode.Uri): vscode.ProviderResult<string> {
-        const editor = vscode.window.activeTextEditor;
-        const client = this.ctx.client;
-        if (!editor || !client) return '';
+    private onDidChangeTextDocument(event: vscode.TextDocumentChangeEvent) {
+        if (isRustDocument(event.document)) {
+            // We need to order this after language server updates, but there's no API for that.
+            // Hence, good old sleep().
+            void sleep(10).then(() => this.eventEmitter.fire(this.uri));
+        }
+    }
+    private onDidChangeActiveTextEditor(editor: vscode.TextEditor | undefined) {
+        if (editor && isRustEditor(editor)) {
+            this.eventEmitter.fire(this.uri);
+        }
+    }
+
+    provideTextDocumentContent(uri: vscode.Uri, ct: vscode.CancellationToken): vscode.ProviderResult<string> {
+        const rustEditor = this.ctx.activeRustEditor;
+        if (!rustEditor) return '';
 
         // When the range based query is enabled we take the range of the selection
-        const range = uri.query === 'range=true' && !editor.selection.isEmpty
-            ? client.code2ProtocolConverter.asRange(editor.selection)
+        const range = uri.query === 'range=true' && !rustEditor.selection.isEmpty
+            ? this.ctx.client.code2ProtocolConverter.asRange(rustEditor.selection)
             : null;
 
-        return client.sendRequest(ra.syntaxTree, {
-            textDocument: { uri: editor.document.uri.toString() },
-            range,
-        });
+        const params = { textDocument: { uri: rustEditor.document.uri.toString() }, range, };
+        return this.ctx.client.sendRequest(ra.syntaxTree, params, ct);
     }
 
     get onDidChange(): vscode.Event<vscode.Uri> {
         return this.eventEmitter.event;
     }
 }
+
+
+// FIXME: consider implementing this via the Tree View API?
+// https://code.visualstudio.com/api/extension-guides/tree-view
+class AstInspector implements vscode.HoverProvider, vscode.DefinitionProvider, Disposable {
+    private readonly astDecorationType = vscode.window.createTextEditorDecorationType({
+        borderColor: new vscode.ThemeColor('rust_analyzer.syntaxTreeBorder'),
+        borderStyle: "solid",
+        borderWidth: "2px",
+
+    });
+    private rustEditor: undefined | RustEditor;
+
+    // Lazy rust token range -> syntax tree file range.
+    private readonly rust2Ast = new Lazy(() => {
+        const astEditor = this.findAstTextEditor();
+        if (!this.rustEditor || !astEditor) return undefined;
+
+        const buf: [vscode.Range, vscode.Range][] = [];
+        for (let i = 0; i < astEditor.document.lineCount; ++i) {
+            const astLine = astEditor.document.lineAt(i);
+
+            // Heuristically look for nodes with quoted text (which are token nodes)
+            const isTokenNode = astLine.text.lastIndexOf('"') >= 0;
+            if (!isTokenNode) continue;
+
+            const rustRange = this.parseRustTextRange(this.rustEditor.document, astLine.text);
+            if (!rustRange) continue;
+
+            buf.push([rustRange, this.findAstNodeRange(astLine)]);
+        }
+        return buf;
+    });
+
+    constructor(ctx: Ctx) {
+        ctx.pushCleanup(vscode.languages.registerHoverProvider({ scheme: AST_FILE_SCHEME }, this));
+        ctx.pushCleanup(vscode.languages.registerDefinitionProvider({ language: "rust" }, this));
+        vscode.workspace.onDidCloseTextDocument(this.onDidCloseTextDocument, this, ctx.subscriptions);
+        vscode.workspace.onDidChangeTextDocument(this.onDidChangeTextDocument, this, ctx.subscriptions);
+        vscode.window.onDidChangeVisibleTextEditors(this.onDidChangeVisibleTextEditors, this, ctx.subscriptions);
+
+        ctx.pushCleanup(this);
+    }
+    dispose() {
+        this.setRustEditor(undefined);
+    }
+
+    private onDidChangeTextDocument(event: vscode.TextDocumentChangeEvent) {
+        if (this.rustEditor && event.document.uri.toString() === this.rustEditor.document.uri.toString()) {
+            this.rust2Ast.reset();
+        }
+    }
+
+    private onDidCloseTextDocument(doc: vscode.TextDocument) {
+        if (this.rustEditor && doc.uri.toString() === this.rustEditor.document.uri.toString()) {
+            this.setRustEditor(undefined);
+        }
+    }
+
+    private onDidChangeVisibleTextEditors(editors: vscode.TextEditor[]) {
+        if (!this.findAstTextEditor()) {
+            this.setRustEditor(undefined);
+            return;
+        }
+        this.setRustEditor(editors.find(isRustEditor));
+    }
+
+    private findAstTextEditor(): undefined | vscode.TextEditor {
+        return vscode.window.visibleTextEditors.find(it => it.document.uri.scheme === AST_FILE_SCHEME);
+    }
+
+    private setRustEditor(newRustEditor: undefined | RustEditor) {
+        if (this.rustEditor && this.rustEditor !== newRustEditor) {
+            this.rustEditor.setDecorations(this.astDecorationType, []);
+            this.rust2Ast.reset();
+        }
+        this.rustEditor = newRustEditor;
+    }
+
+    // additional positional params are omitted
+    provideDefinition(doc: vscode.TextDocument, pos: vscode.Position): vscode.ProviderResult<vscode.DefinitionLink[]> {
+        if (!this.rustEditor || doc.uri.toString() !== this.rustEditor.document.uri.toString()) return;
+
+        const astEditor = this.findAstTextEditor();
+        if (!astEditor) return;
+
+        const rust2AstRanges = this.rust2Ast.get()?.find(([rustRange, _]) => rustRange.contains(pos));
+        if (!rust2AstRanges) return;
+
+        const [rustFileRange, astFileRange] = rust2AstRanges;
+
+        astEditor.revealRange(astFileRange);
+        astEditor.selection = new vscode.Selection(astFileRange.start, astFileRange.end);
+
+        return [{
+            targetRange: astFileRange,
+            targetUri: astEditor.document.uri,
+            originSelectionRange: rustFileRange,
+            targetSelectionRange: astFileRange,
+        }];
+    }
+
+    // additional positional params are omitted
+    provideHover(doc: vscode.TextDocument, hoverPosition: vscode.Position): vscode.ProviderResult<vscode.Hover> {
+        if (!this.rustEditor) return;
+
+        const astFileLine = doc.lineAt(hoverPosition.line);
+
+        const rustFileRange = this.parseRustTextRange(this.rustEditor.document, astFileLine.text);
+        if (!rustFileRange) return;
+
+        this.rustEditor.setDecorations(this.astDecorationType, [rustFileRange]);
+        this.rustEditor.revealRange(rustFileRange);
+
+        const rustSourceCode = this.rustEditor.document.getText(rustFileRange);
+        const astFileRange = this.findAstNodeRange(astFileLine);
+
+        return new vscode.Hover(["```rust\n" + rustSourceCode + "\n```"], astFileRange);
+    }
+
+    private findAstNodeRange(astLine: vscode.TextLine) {
+        const lineOffset = astLine.range.start;
+        const begin = lineOffset.translate(undefined, astLine.firstNonWhitespaceCharacterIndex);
+        const end = lineOffset.translate(undefined, astLine.text.trimEnd().length);
+        return new vscode.Range(begin, end);
+    }
+
+    private parseRustTextRange(doc: vscode.TextDocument, astLine: string): undefined | vscode.Range {
+        const parsedRange = /\[(\d+); (\d+)\)/.exec(astLine);
+        if (!parsedRange) return;
+
+        const [begin, end] = parsedRange.slice(1).map(off => doc.positionAt(+off));
+
+        return new vscode.Range(begin, end);
+    }
+}
+
+class Lazy<T> {
+    val: undefined | T;
+
+    constructor(private readonly compute: () => undefined | T) { }
+
+    get() {
+        return this.val ?? (this.val = this.compute());
+    }
+
+    reset() {
+        this.val = undefined;
+    }
+}
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index e77462c1b..1f45f1de0 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -11,10 +11,9 @@ export class Config {
     private readonly rootSection = "rust-analyzer";
     private readonly requiresReloadOpts = [
         "serverPath",
-        "cargoFeatures",
-        "cargo-watch",
-        "highlighting.semanticTokens",
-        "inlayHints",
+        "cargo",
+        "files",
+        "highlighting",
         "updates.channel",
     ]
         .map(opt => `${this.rootSection}.${opt}`);
@@ -71,19 +70,8 @@ export class Config {
     get channel() { return this.cfg.get<UpdatesChannel>("updates.channel")!; }
     get askBeforeDownload() { return this.cfg.get<boolean>("updates.askBeforeDownload")!; }
     get highlightingSemanticTokens() { return this.cfg.get<boolean>("highlighting.semanticTokens")!; }
-    get highlightingOn() { return this.cfg.get<boolean>("highlightingOn")!; }
-    get rainbowHighlightingOn() { return this.cfg.get<boolean>("rainbowHighlightingOn")!; }
-    get lruCapacity() { return this.cfg.get<null | number>("lruCapacity")!; }
-    get excludeGlobs() { return this.cfg.get<string[]>("excludeGlobs")!; }
-    get useClientWatching() { return this.cfg.get<boolean>("useClientWatching")!; }
-    get featureFlags() { return this.cfg.get<Record<string, boolean>>("featureFlags")!; }
-    get rustfmtArgs() { return this.cfg.get<string[]>("rustfmtArgs")!; }
-    get loadOutDirsFromCheck() { return this.cfg.get<boolean>("loadOutDirsFromCheck")!; }
     get traceExtension() { return this.cfg.get<boolean>("trace.extension")!; }
 
-    // for internal use
-    get withSysroot() { return this.cfg.get<boolean>("withSysroot", true)!; }
-
     get inlayHints() {
         return {
             typeHints: this.cfg.get<boolean>("inlayHints.typeHints")!,
@@ -93,21 +81,9 @@ export class Config {
         };
     }
 
-    get cargoWatchOptions() {
-        return {
-            enable: this.cfg.get<boolean>("cargo-watch.enable")!,
-            arguments: this.cfg.get<string[]>("cargo-watch.arguments")!,
-            allTargets: this.cfg.get<boolean>("cargo-watch.allTargets")!,
-            command: this.cfg.get<string>("cargo-watch.command")!,
-        };
-    }
-
-    get cargoFeatures() {
+    get checkOnSave() {
         return {
-            noDefaultFeatures: this.cfg.get<boolean>("cargoFeatures.noDefaultFeatures")!,
-            allFeatures: this.cfg.get<boolean>("cargoFeatures.allFeatures")!,
-            features: this.cfg.get<string[]>("cargoFeatures.features")!,
-            loadOutDirsFromCheck: this.cfg.get<boolean>("cargoFeatures.loadOutDirsFromCheck")!,
+            command: this.cfg.get<string>("checkOnSave.command")!,
         };
     }
 }
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index 84c170ea8..bd1c3de07 100644
--- a/editors/code/src/ctx.ts
+++ b/editors/code/src/ctx.ts
@@ -15,8 +15,13 @@ export class Ctx {
 
     }
 
-    static async create(config: Config, extCtx: vscode.ExtensionContext, serverPath: string): Promise<Ctx> {
-        const client = await createClient(config, serverPath);
+    static async create(
+        config: Config,
+        extCtx: vscode.ExtensionContext,
+        serverPath: string,
+        cwd: string,
+    ): Promise<Ctx> {
+        const client = await createClient(config, serverPath, cwd);
         const res = new Ctx(config, extCtx, client, serverPath);
         res.pushCleanup(client.start());
         await client.onReady();
diff --git a/editors/code/src/highlighting.ts b/editors/code/src/highlighting.ts
deleted file mode 100644
index ea2dfc0e3..000000000
--- a/editors/code/src/highlighting.ts
+++ /dev/null
@@ -1,255 +0,0 @@
-import * as vscode from 'vscode';
-import * as ra from './rust-analyzer-api';
-
-import { ColorTheme, TextMateRuleSettings } from './color_theme';
-
-import { Ctx } from './ctx';
-import { sendRequestWithRetry, isRustDocument } from './util';
-
-export function activateHighlighting(ctx: Ctx) {
-    const highlighter = new Highlighter(ctx);
-
-    ctx.client.onNotification(ra.publishDecorations, params => {
-        if (!ctx.config.highlightingOn) return;
-
-        const targetEditor = vscode.window.visibleTextEditors.find(
-            editor => {
-                const unescapedUri = unescape(
-                    editor.document.uri.toString(),
-                );
-                // Unescaped URI looks like:
-                // file:///c:/Workspace/ra-test/src/main.rs
-                return unescapedUri === params.uri;
-            },
-        );
-        if (!targetEditor) return;
-
-        highlighter.setHighlights(targetEditor, params.decorations);
-    });
-
-
-    vscode.workspace.onDidChangeConfiguration(
-        _ => highlighter.removeHighlights(),
-        null,
-        ctx.subscriptions,
-    );
-
-    vscode.window.onDidChangeActiveTextEditor(
-        async (editor: vscode.TextEditor | undefined) => {
-            if (!editor || !isRustDocument(editor.document)) return;
-            if (!ctx.config.highlightingOn) return;
-            const client = ctx.client;
-            if (!client) return;
-
-            const decorations = await sendRequestWithRetry(
-                client,
-                ra.decorationsRequest,
-                { uri: editor.document.uri.toString() },
-            );
-            highlighter.setHighlights(editor, decorations);
-        },
-        null,
-        ctx.subscriptions,
-    );
-}
-
-// Based on this HSL-based color generator: https://gist.github.com/bendc/76c48ce53299e6078a76
-function fancify(seed: string, shade: 'light' | 'dark') {
-    const random = randomU32Numbers(hashString(seed));
-    const randomInt = (min: number, max: number) => {
-        return Math.abs(random()) % (max - min + 1) + min;
-    };
-
-    const h = randomInt(0, 360);
-    const s = randomInt(42, 98);
-    const l = shade === 'light' ? randomInt(15, 40) : randomInt(40, 90);
-    return `hsl(${h},${s}%,${l}%)`;
-}
-
-class Highlighter {
-    private ctx: Ctx;
-    private decorations: Map<
-        string,
-        vscode.TextEditorDecorationType
-    > | null = null;
-
-    constructor(ctx: Ctx) {
-        this.ctx = ctx;
-    }
-
-    public removeHighlights() {
-        if (this.decorations == null) {
-            return;
-        }
-
-        // Decorations are removed when the object is disposed
-        for (const decoration of this.decorations.values()) {
-            decoration.dispose();
-        }
-
-        this.decorations = null;
-    }
-
-    public setHighlights(editor: vscode.TextEditor, highlights: ra.Decoration[]) {
-        const client = this.ctx.client;
-        if (!client) return;
-        // Initialize decorations if necessary
-        //
-        // Note: decoration objects need to be kept around so we can dispose them
-        // if the user disables syntax highlighting
-        if (this.decorations == null) {
-            this.decorations = initDecorations();
-        }
-
-        const byTag: Map<string, vscode.Range[]> = new Map();
-        const colorfulIdents: Map<
-            string,
-            [vscode.Range[], boolean]
-        > = new Map();
-        const rainbowTime = this.ctx.config.rainbowHighlightingOn;
-
-        for (const tag of this.decorations.keys()) {
-            byTag.set(tag, []);
-        }
-
-        for (const d of highlights) {
-            if (!byTag.get(d.tag)) {
-                continue;
-            }
-
-            if (rainbowTime && d.bindingHash) {
-                if (!colorfulIdents.has(d.bindingHash)) {
-                    const mut = d.tag.endsWith('.mut');
-                    colorfulIdents.set(d.bindingHash, [[], mut]);
-                }
-                colorfulIdents
-                    .get(d.bindingHash)![0]
-                    .push(
-                        client.protocol2CodeConverter.asRange(d.range),
-                    );
-            } else {
-                byTag
-                    .get(d.tag)!
-                    .push(
-                        client.protocol2CodeConverter.asRange(d.range),
-                    );
-            }
-        }
-
-        for (const tag of byTag.keys()) {
-            const dec = this.decorations.get(
-                tag,
-            ) as vscode.TextEditorDecorationType;
-            const ranges = byTag.get(tag)!;
-            editor.setDecorations(dec, ranges);
-        }
-
-        for (const [hash, [ranges, mut]] of colorfulIdents.entries()) {
-            const textDecoration = mut ? 'underline' : undefined;
-            const dec = vscode.window.createTextEditorDecorationType({
-                light: { color: fancify(hash, 'light'), textDecoration },
-                dark: { color: fancify(hash, 'dark'), textDecoration },
-            });
-            editor.setDecorations(dec, ranges);
-        }
-    }
-}
-
-function initDecorations(): Map<string, vscode.TextEditorDecorationType> {
-    const theme = ColorTheme.load();
-    const res = new Map();
-    TAG_TO_SCOPES.forEach((scopes, tag) => {
-        // We are going to axe this soon, so don't try to detect unknown tags.
-        // Users should switch to the new semantic tokens implementation.
-        if (!scopes) return;
-        const rule = theme.lookup(scopes);
-        const decor = createDecorationFromTextmate(rule);
-        res.set(tag, decor);
-    });
-    return res;
-}
-
-function createDecorationFromTextmate(
-    themeStyle: TextMateRuleSettings,
-): vscode.TextEditorDecorationType {
-    const decorationOptions: vscode.DecorationRenderOptions = {};
-    decorationOptions.rangeBehavior = vscode.DecorationRangeBehavior.OpenOpen;
-
-    if (themeStyle.foreground) {
-        decorationOptions.color = themeStyle.foreground;
-    }
-
-    if (themeStyle.background) {
-        decorationOptions.backgroundColor = themeStyle.background;
-    }
-
-    if (themeStyle.fontStyle) {
-        const parts: string[] = themeStyle.fontStyle.split(' ');
-        parts.forEach(part => {
-            switch (part) {
-                case 'italic':
-                    decorationOptions.fontStyle = 'italic';
-                    break;
-                case 'bold':
-                    decorationOptions.fontWeight = 'bold';
-                    break;
-                case 'underline':
-                    decorationOptions.textDecoration = 'underline';
-                    break;
-                default:
-                    break;
-            }
-        });
-    }
-    return vscode.window.createTextEditorDecorationType(decorationOptions);
-}
-
-// sync with tags from `syntax_highlighting.rs`.
-const TAG_TO_SCOPES = new Map<string, string[]>([
-    ["field", ["entity.name.field"]],
-    ["function", ["entity.name.function"]],
-    ["module", ["entity.name.module"]],
-    ["constant", ["entity.name.constant"]],
-    ["macro", ["entity.name.macro"]],
-
-    ["variable", ["variable"]],
-    ["variable.mutable", ["variable", "meta.mutable"]],
-
-    ["type", ["entity.name.type"]],
-    ["type.builtin", ["entity.name.type", "support.type.primitive"]],
-    ["type.self", ["entity.name.type.parameter.self"]],
-    ["type.param", ["entity.name.type.parameter", "entity.name.type.param.rust"]],
-    ["type.lifetime", ["entity.name.type.lifetime", "entity.name.lifetime.rust"]],
-
-    ["literal.byte", ["constant.character.byte"]],
-    ["literal.char", ["constant.character.rust"]],
-    ["numeric_literal", ["constant.numeric"]],
-
-    ["comment", ["comment"]],
-    ["string_literal", ["string.quoted"]],
-    ["attribute", ["meta.attribute.rust"]],
-
-    ["keyword", ["keyword"]],
-    ["keyword.unsafe", ["keyword.other.unsafe"]],
-    ["keyword.control", ["keyword.control"]],
-]);
-
-function randomU32Numbers(seed: number) {
-    let random = seed | 0;
-    return () => {
-        random ^= random << 13;
-        random ^= random >> 17;
-        random ^= random << 5;
-        random |= 0;
-        return random;
-    };
-}
-
-function hashString(str: string): number {
-    let res = 0;
-    for (let i = 0; i < str.length; ++i) {
-        const c = str.codePointAt(i)!;
-        res = (res * 31 + c) & ~0;
-    }
-    return res;
-}
diff --git a/editors/code/src/inlay_hints.ts b/editors/code/src/inlay_hints.ts
index 542d1f367..6a8bd942e 100644
--- a/editors/code/src/inlay_hints.ts
+++ b/editors/code/src/inlay_hints.ts
@@ -17,7 +17,11 @@ export function activateInlayHints(ctx: Ctx) {
             ) {
                 return this.dispose();
             }
-            if (!this.updater) this.updater = new HintsUpdater(ctx);
+            if (this.updater) {
+                this.updater.syncCacheAndRenderHints();
+            } else {
+                this.updater = new HintsUpdater(ctx);
+            }
         },
         dispose() {
             this.updater?.dispose();
@@ -124,7 +128,7 @@ class HintsUpdater implements Disposable {
         this.syncCacheAndRenderHints();
     }
 
-    private syncCacheAndRenderHints() {
+    syncCacheAndRenderHints() {
         // FIXME: make inlayHints request pass an array of files?
         this.sourceFiles.forEach((file, uri) => this.fetchHints(file).then(hints => {
             if (!hints) return;
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index 980ed925b..4f3b89f44 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -7,12 +7,12 @@ import * as commands from './commands';
 import { activateInlayHints } from './inlay_hints';
 import { activateStatusDisplay } from './status_display';
 import { Ctx } from './ctx';
-import { activateHighlighting } from './highlighting';
 import { Config, NIGHTLY_TAG } from './config';
 import { log, assert } from './util';
 import { PersistentState } from './persistent_state';
 import { fetchRelease, download } from './net';
 import { spawnSync } from 'child_process';
+import { activateTaskProvider } from './tasks';
 
 let ctx: Ctx | undefined;
 
@@ -41,11 +41,18 @@ export async function activate(context: vscode.ExtensionContext) {
     const state = new PersistentState(context.globalState);
     const serverPath = await bootstrap(config, state);
 
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    if (workspaceFolder === undefined) {
+        const err = "Cannot activate rust-analyzer when no folder is opened";
+        void vscode.window.showErrorMessage(err);
+        throw new Error(err);
+    }
+
     // Note: we try to start the server before we activate type hints so that it
     // registers its `onDidChangeDocument` handler before us.
     //
     // This a horribly, horribly wrong way to deal with this problem.
-    ctx = await Ctx.create(config, context, serverPath);
+    ctx = await Ctx.create(config, context, serverPath, workspaceFolder.uri.fsPath);
 
     // Commands which invokes manually via command palette, shortcut, etc.
 
@@ -85,12 +92,17 @@ export async function activate(context: vscode.ExtensionContext) {
     ctx.registerCommand('applySourceChange', commands.applySourceChange);
     ctx.registerCommand('selectAndApplySourceChange', commands.selectAndApplySourceChange);
 
+    ctx.pushCleanup(activateTaskProvider(workspaceFolder));
+
     activateStatusDisplay(ctx);
 
-    if (!ctx.config.highlightingSemanticTokens) {
-        activateHighlighting(ctx);
-    }
     activateInlayHints(ctx);
+
+    vscode.workspace.onDidChangeConfiguration(
+        _ => ctx?.client?.sendNotification('workspace/didChangeConfiguration', { settings: "" }),
+        null,
+        ctx.subscriptions,
+    );
 }
 
 export async function deactivate() {
diff --git a/editors/code/src/status_display.ts b/editors/code/src/status_display.ts
index 0f5f6ef99..f9cadc8a2 100644
--- a/editors/code/src/status_display.ts
+++ b/editors/code/src/status_display.ts
@@ -7,7 +7,7 @@ import { Ctx } from './ctx';
 const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
 export function activateStatusDisplay(ctx: Ctx) {
-    const statusDisplay = new StatusDisplay(ctx.config.cargoWatchOptions.command);
+    const statusDisplay = new StatusDisplay(ctx.config.checkOnSave.command);
     ctx.pushCleanup(statusDisplay);
     const client = ctx.client;
     if (client != null) {
diff --git a/editors/code/src/tasks.ts b/editors/code/src/tasks.ts
new file mode 100644
index 000000000..fa1c4a951
--- /dev/null
+++ b/editors/code/src/tasks.ts
@@ -0,0 +1,52 @@
+import * as vscode from 'vscode';
+
+// This ends up as the `type` key in tasks.json. RLS also uses `cargo` and
+// our configuration should be compatible with it so use the same key.
+const TASK_TYPE = 'cargo';
+
+export function activateTaskProvider(target: vscode.WorkspaceFolder): vscode.Disposable {
+    const provider: vscode.TaskProvider = {
+        // Detect Rust tasks. Currently we do not do any actual detection
+        // of tasks (e.g. aliases in .cargo/config) and just return a fixed
+        // set of tasks that always exist. These tasks cannot be removed in
+        // tasks.json - only tweaked.
+        provideTasks: () => getStandardCargoTasks(target),
+
+        // We don't need to implement this.
+        resolveTask: () => undefined,
+    };
+
+    return vscode.tasks.registerTaskProvider(TASK_TYPE, provider);
+}
+
+function getStandardCargoTasks(target: vscode.WorkspaceFolder): vscode.Task[] {
+    return [
+        { command: 'build', group: vscode.TaskGroup.Build },
+        { command: 'check', group: vscode.TaskGroup.Build },
+        { command: 'test', group: vscode.TaskGroup.Test },
+        { command: 'clean', group: vscode.TaskGroup.Clean },
+        { command: 'run', group: undefined },
+    ]
+        .map(({ command, group }) => {
+            const vscodeTask = new vscode.Task(
+                // The contents of this object end up in the tasks.json entries.
+                {
+                    type: TASK_TYPE,
+                    command,
+                },
+                // The scope of the task - workspace or specific folder (global
+                // is not supported).
+                target,
+                // The task name, and task source. These are shown in the UI as
+                // `${source}: ${name}`, e.g. `rust: cargo build`.
+                `cargo ${command}`,
+                'rust',
+                // What to do when this command is executed.
+                new vscode.ShellExecution('cargo', [command]),
+                // Problem matchers.
+                ['$rustc'],
+            );
+            vscodeTask.group = group;
+            return vscodeTask;
+        });
+}
diff --git a/editors/code/src/util.ts b/editors/code/src/util.ts
index 978a31751..6f91f81d6 100644
--- a/editors/code/src/util.ts
+++ b/editors/code/src/util.ts
@@ -65,12 +65,12 @@ export async function sendRequestWithRetry<TParam, TRet>(
     throw 'unreachable';
 }
 
-function sleep(ms: number) {
+export function sleep(ms: number) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
 export type RustDocument = vscode.TextDocument & { languageId: "rust" };
-export type RustEditor = vscode.TextEditor & { document: RustDocument; id: string };
+export type RustEditor = vscode.TextEditor & { document: RustDocument };
 
 export function isRustDocument(document: vscode.TextDocument): document is RustDocument {
     return document.languageId === 'rust'