8 files changed, 226 insertions, 88 deletions

diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index b7220d8e2..955a05066 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -84,9 +84,9 @@
             "dev": true
         },
         "@types/node": {
-            "version": "12.12.30",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-12.12.30.tgz",
-            "integrity": "sha512-sz9MF/zk6qVr3pAnM0BSQvYIBK44tS75QC5N+VbWSE4DjCV/pJ+UzCW/F+vVnl7TkOPcuwQureKNtSSwjBTaMg==",
+            "version": "12.12.34",
+            "resolved": "https://registry.npmjs.org/@types/node/-/node-12.12.34.tgz",
+            "integrity": "sha512-BneGN0J9ke24lBRn44hVHNeDlrXRYF+VRp0HbSUNnEZahXGAysHZIqnf/hER6aabdBgzM4YOV4jrR8gj4Zfi0g==",
             "dev": true
         },
         "@types/node-fetch": {
@@ -115,45 +115,56 @@
             "dev": true
         },
         "@typescript-eslint/eslint-plugin": {
-            "version": "2.24.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-2.24.0.tgz",
-            "integrity": "sha512-wJRBeaMeT7RLQ27UQkDFOu25MqFOBus8PtOa9KaT5ZuxC1kAsd7JEHqWt4YXuY9eancX0GK9C68i5OROnlIzBA==",
+            "version": "2.26.0",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-2.26.0.tgz",
+            "integrity": "sha512-4yUnLv40bzfzsXcTAtZyTjbiGUXMrcIJcIMioI22tSOyAxpdXiZ4r7YQUU8Jj6XXrLz9d5aMHPQf5JFR7h27Nw==",
             "dev": true,
             "requires": {
-                "@typescript-eslint/experimental-utils": "2.24.0",
-                "eslint-utils": "^1.4.3",
+                "@typescript-eslint/experimental-utils": "2.26.0",
                 "functional-red-black-tree": "^1.0.1",
                 "regexpp": "^3.0.0",
                 "tsutils": "^3.17.1"
             }
         },
         "@typescript-eslint/experimental-utils": {
-            "version": "2.24.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-2.24.0.tgz",
-            "integrity": "sha512-DXrwuXTdVh3ycNCMYmWhUzn/gfqu9N0VzNnahjiDJvcyhfBy4gb59ncVZVxdp5XzBC77dCncu0daQgOkbvPwBw==",
+            "version": "2.26.0",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-2.26.0.tgz",
+            "integrity": "sha512-RELVoH5EYd+JlGprEyojUv9HeKcZqF7nZUGSblyAw1FwOGNnmQIU8kxJ69fttQvEwCsX5D6ECJT8GTozxrDKVQ==",
             "dev": true,
             "requires": {
                 "@types/json-schema": "^7.0.3",
-                "@typescript-eslint/typescript-estree": "2.24.0",
-                "eslint-scope": "^5.0.0"
+                "@typescript-eslint/typescript-estree": "2.26.0",
+                "eslint-scope": "^5.0.0",
+                "eslint-utils": "^2.0.0"
+            },
+            "dependencies": {
+                "eslint-utils": {
+                    "version": "2.0.0",
+                    "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-2.0.0.tgz",
+                    "integrity": "sha512-0HCPuJv+7Wv1bACm8y5/ECVfYdfsAm9xmVb7saeFlxjPYALefjhbYoCkBjPdPzGH8wWyTpAez82Fh3VKYEZ8OA==",
+                    "dev": true,
+                    "requires": {
+                        "eslint-visitor-keys": "^1.1.0"
+                    }
+                }
             }
         },
         "@typescript-eslint/parser": {
-            "version": "2.24.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-2.24.0.tgz",
-            "integrity": "sha512-H2Y7uacwSSg8IbVxdYExSI3T7uM1DzmOn2COGtCahCC3g8YtM1xYAPi2MAHyfPs61VKxP/J/UiSctcRgw4G8aw==",
+            "version": "2.26.0",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-2.26.0.tgz",
+            "integrity": "sha512-+Xj5fucDtdKEVGSh9353wcnseMRkPpEAOY96EEenN7kJVrLqy/EVwtIh3mxcUz8lsFXW1mT5nN5vvEam/a5HiQ==",
             "dev": true,
             "requires": {
                 "@types/eslint-visitor-keys": "^1.0.0",
-                "@typescript-eslint/experimental-utils": "2.24.0",
-                "@typescript-eslint/typescript-estree": "2.24.0",
+                "@typescript-eslint/experimental-utils": "2.26.0",
+                "@typescript-eslint/typescript-estree": "2.26.0",
                 "eslint-visitor-keys": "^1.1.0"
             }
         },
         "@typescript-eslint/typescript-estree": {
-            "version": "2.24.0",
-            "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-2.24.0.tgz",
-            "integrity": "sha512-RJ0yMe5owMSix55qX7Mi9V6z2FDuuDpN6eR5fzRJrp+8in9UF41IGNQHbg5aMK4/PjVaEQksLvz0IA8n+Mr/FA==",
+            "version": "2.26.0",
+            "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-2.26.0.tgz",
+            "integrity": "sha512-3x4SyZCLB4zsKsjuhxDLeVJN6W29VwBnYpCsZ7vIdPel9ZqLfIZJgJXO47MNUkurGpQuIBALdPQKtsSnWpE1Yg==",
             "dev": true,
             "requires": {
                 "debug": "^4.1.1",
@@ -1388,9 +1399,9 @@
             }
         },
         "rollup": {
-            "version": "2.1.0",
-            "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.1.0.tgz",
-            "integrity": "sha512-gfE1455AEazVVTJoeQtcOq/U6GSxwoj4XPSWVsuWmgIxj7sBQNLDOSA82PbdMe+cP8ql8fR1jogPFe8Wg8g4SQ==",
+            "version": "2.3.1",
+            "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.3.1.tgz",
+            "integrity": "sha512-BRjzOauORe+R0U0I6SkMTSG22nYmtztR/TaBl0SvbXgc3VAxBDrZoB6HROiK0S5px1pUBnLnjBkbzmVuwC9Q1Q==",
             "dev": true,
             "requires": {
                 "fsevents": "~2.1.2"
diff --git a/editors/code/package.json b/editors/code/package.json
index 37e083220..ba31c4e63 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -39,13 +39,13 @@
     "devDependencies": {
         "@rollup/plugin-commonjs": "^11.0.2",
         "@rollup/plugin-node-resolve": "^7.1.1",
-        "@types/node": "^12.12.30",
+        "@types/node": "^12.12.34",
         "@types/node-fetch": "^2.5.5",
         "@types/vscode": "^1.43.0",
-        "@typescript-eslint/eslint-plugin": "^2.24.0",
-        "@typescript-eslint/parser": "^2.24.0",
+        "@typescript-eslint/eslint-plugin": "^2.26.0",
+        "@typescript-eslint/parser": "^2.26.0",
         "eslint": "^6.8.0",
-        "rollup": "^2.1.0",
+        "rollup": "^2.3.1",
         "tslib": "^1.11.1",
         "typescript": "^3.8.3",
         "typescript-formatter": "^7.2.2",
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index d72ecc58f..f909f8db2 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -30,15 +30,14 @@ export function configToServerOptions(config: Config) {
     };
 }
 
-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,
diff --git a/editors/code/src/commands/syntax_tree.ts b/editors/code/src/commands/syntax_tree.ts
index 2e08e8f11..996c7a716 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,13 @@ 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));
 
     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 +28,126 @@ 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');
+    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, Disposable {
+    private static readonly astDecorationType = vscode.window.createTextEditorDecorationType({
+        fontStyle: "normal",
+        border: "#ffffff 1px solid",
+    });
+    private rustEditor: undefined | RustEditor;
+
+    constructor(ctx: Ctx) {
+        ctx.pushCleanup(vscode.languages.registerHoverProvider({ scheme: AST_FILE_SCHEME }, this));
+        vscode.workspace.onDidCloseTextDocument(this.onDidCloseTextDocument, this, ctx.subscriptions);
+        vscode.window.onDidChangeVisibleTextEditors(this.onDidChangeVisibleTextEditors, this, ctx.subscriptions);
+
+        ctx.pushCleanup(this);
+    }
+    dispose() {
+        this.setRustEditor(undefined);
+    }
+
+    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 (editors.every(suspect => suspect.document.uri.scheme !== AST_FILE_SCHEME)) {
+            this.setRustEditor(undefined);
+            return;
+        }
+        this.setRustEditor(editors.find(isRustEditor));
+    }
+
+    private setRustEditor(newRustEditor: undefined | RustEditor) {
+        if (newRustEditor !== this.rustEditor) {
+            this.rustEditor?.setDecorations(AstInspector.astDecorationType, []);
+        }
+        this.rustEditor = newRustEditor;
+    }
+
+    provideHover(doc: vscode.TextDocument, hoverPosition: vscode.Position): vscode.ProviderResult<vscode.Hover> {
+        if (!this.rustEditor) return;
+
+        const astTextLine = doc.lineAt(hoverPosition.line);
+
+        const rustTextRange = this.parseRustTextRange(this.rustEditor.document, astTextLine.text);
+        if (!rustTextRange) return;
+
+        this.rustEditor.setDecorations(AstInspector.astDecorationType, [rustTextRange]);
+        this.rustEditor.revealRange(rustTextRange);
+
+        const rustSourceCode = this.rustEditor.document.getText(rustTextRange);
+        const astTextRange = this.findAstRange(astTextLine);
+
+        return new vscode.Hover(["```rust\n" + rustSourceCode + "\n```"], astTextRange);
+    }
+
+    private findAstRange(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);
+    }
+}
diff --git a/editors/code/src/ctx.ts b/editors/code/src/ctx.ts
index d2f49cd23..86b5f3629 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/main.ts b/editors/code/src/main.ts
index a46dbde33..7ba16120c 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -13,6 +13,7 @@ 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 +42,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,6 +93,8 @@ 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) {
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'