8 files changed, 404 insertions, 30 deletions

diff --git a/editors/code/src/commands/cargo_watch.ts b/editors/code/src/commands/cargo_watch.ts
new file mode 100644
index 000000000..d45d0e7d1
--- /dev/null
+++ b/editors/code/src/commands/cargo_watch.ts
@@ -0,0 +1,235 @@
+import * as child_process from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as vscode from 'vscode';
+import { Server } from '../server';
+import { terminate } from '../utils/processes';
+import { LineBuffer } from './line_buffer';
+import { StatusDisplay } from './watch_status';
+
+export class CargoWatchProvider {
+    private diagnosticCollection?: vscode.DiagnosticCollection;
+    private cargoProcess?: child_process.ChildProcess;
+    private outBuffer: string = '';
+    private statusDisplay?: StatusDisplay;
+    private outputChannel?: vscode.OutputChannel;
+
+    public activate(subscriptions: vscode.Disposable[]) {
+        let cargoExists = false;
+        const cargoTomlFile = path.join(
+            vscode.workspace.rootPath!,
+            'Cargo.toml'
+        );
+        // Check if the working directory is valid cargo root path
+        try {
+            if (fs.existsSync(cargoTomlFile)) {
+                cargoExists = true;
+            }
+        } catch (err) {
+            cargoExists = false;
+        }
+
+        if (!cargoExists) {
+            vscode.window.showErrorMessage(
+                `Couldn\'t find \'Cargo.toml\' in ${cargoTomlFile}`
+            );
+            return;
+        }
+
+        subscriptions.push(this);
+        this.diagnosticCollection = vscode.languages.createDiagnosticCollection(
+            'rustc'
+        );
+
+        this.statusDisplay = new StatusDisplay(subscriptions);
+        this.outputChannel = vscode.window.createOutputChannel(
+            'Cargo Watch Trace'
+        );
+
+        let args = '"check --message-format json';
+        if (Server.config.cargoWatchOptions.checkArguments.length > 0) {
+            // Excape the double quote string:
+            args += ' ' + Server.config.cargoWatchOptions.checkArguments;
+        }
+        args += '"';
+
+        // Start the cargo watch with json message
+        this.cargoProcess = child_process.spawn(
+            'cargo',
+            ['watch', '-x', args],
+            {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                cwd: vscode.workspace.rootPath,
+                windowsVerbatimArguments: true
+            }
+        );
+
+        const stdoutData = new LineBuffer();
+        this.cargoProcess.stdout.on('data', (s: string) => {
+            stdoutData.processOutput(s, line => {
+                this.logInfo(line);
+                try {
+                    this.parseLine(line);
+                } catch (err) {
+                    this.logError(`Failed to parse: ${err}, content : ${line}`);
+                }
+            });
+        });
+
+        const stderrData = new LineBuffer();
+        this.cargoProcess.stderr.on('data', (s: string) => {
+            stderrData.processOutput(s, line => {
+                this.logError('Error on cargo-watch : {\n' + line + '}\n');
+            });
+        });
+
+        this.cargoProcess.on('error', (err: Error) => {
+            this.logError(
+                'Error on cargo-watch process : {\n' + err.message + '}\n'
+            );
+        });
+
+        this.logInfo('cargo-watch started.');
+    }
+
+    public dispose(): void {
+        if (this.diagnosticCollection) {
+            this.diagnosticCollection.clear();
+            this.diagnosticCollection.dispose();
+        }
+
+        if (this.cargoProcess) {
+            this.cargoProcess.kill();
+            terminate(this.cargoProcess);
+        }
+
+        if (this.outputChannel) {
+            this.outputChannel.dispose();
+        }
+    }
+
+    private logInfo(line: string) {
+        if (Server.config.cargoWatchOptions.trace === 'verbose') {
+            this.outputChannel!.append(line);
+        }
+    }
+
+    private logError(line: string) {
+        if (
+            Server.config.cargoWatchOptions.trace === 'error' ||
+            Server.config.cargoWatchOptions.trace === 'verbose'
+        ) {
+            this.outputChannel!.append(line);
+        }
+    }
+
+    private parseLine(line: string) {
+        if (line.startsWith('[Running')) {
+            this.diagnosticCollection!.clear();
+            this.statusDisplay!.show();
+        }
+
+        if (line.startsWith('[Finished running')) {
+            this.statusDisplay!.hide();
+        }
+
+        function getLevel(s: string): vscode.DiagnosticSeverity {
+            if (s === 'error') {
+                return vscode.DiagnosticSeverity.Error;
+            }
+            if (s.startsWith('warn')) {
+                return vscode.DiagnosticSeverity.Warning;
+            }
+            return vscode.DiagnosticSeverity.Information;
+        }
+
+        // Reference:
+        // https://github.com/rust-lang/rust/blob/master/src/libsyntax/json.rs
+        interface RustDiagnosticSpan {
+            line_start: number;
+            line_end: number;
+            column_start: number;
+            column_end: number;
+            is_primary: boolean;
+            file_name: string;
+        }
+
+        interface RustDiagnostic {
+            spans: RustDiagnosticSpan[];
+            rendered: string;
+            level: string;
+            code?: {
+                code: string;
+            };
+        }
+
+        interface CargoArtifact {
+            reason: string;
+            package_id: string;
+        }
+
+        // https://github.com/rust-lang/cargo/blob/master/src/cargo/util/machine_message.rs
+        interface CargoMessage {
+            reason: string;
+            package_id: string;
+            message: RustDiagnostic;
+        }
+
+        // cargo-watch itself output non json format
+        // Ignore these lines
+        let data: CargoMessage;
+        try {
+            data = JSON.parse(line.trim());
+        } catch (error) {
+            this.logError(`Fail to parse to json : { ${error} }`);
+            return;
+        }
+
+        if (data.reason === 'compiler-artifact') {
+            const msg = data as CargoArtifact;
+
+            // The format of the package_id is "{name} {version} ({source_id})",
+            // https://github.com/rust-lang/cargo/blob/37ad03f86e895bb80b474c1c088322634f4725f5/src/cargo/core/package_id.rs#L53
+            this.statusDisplay!.packageName = msg.package_id.split(' ')[0];
+        } else if (data.reason === 'compiler-message') {
+            const msg = data.message as RustDiagnostic;
+
+            const spans = msg.spans.filter(o => o.is_primary);
+
+            // We only handle primary span right now.
+            if (spans.length > 0) {
+                const o = spans[0];
+
+                const rendered = msg.rendered;
+                const level = getLevel(msg.level);
+                const range = new vscode.Range(
+                    new vscode.Position(o.line_start - 1, o.column_start - 1),
+                    new vscode.Position(o.line_end - 1, o.column_end - 1)
+                );
+
+                const fileName = path.join(
+                    vscode.workspace.rootPath!,
+                    o.file_name
+                );
+                const diagnostic = new vscode.Diagnostic(
+                    range,
+                    rendered,
+                    level
+                );
+
+                diagnostic.source = 'rustc';
+                diagnostic.code = msg.code ? msg.code.code : undefined;
+                diagnostic.relatedInformation = [];
+
+                const fileUrl = vscode.Uri.file(fileName!);
+
+                const diagnostics: vscode.Diagnostic[] = [
+                    ...(this.diagnosticCollection!.get(fileUrl) || [])
+                ];
+                diagnostics.push(diagnostic);
+
+                this.diagnosticCollection!.set(fileUrl, diagnostics);
+            }
+        }
+    }
+}
diff --git a/editors/code/src/commands/line_buffer.ts b/editors/code/src/commands/line_buffer.ts
new file mode 100644
index 000000000..fb5b9f7f2
--- /dev/null
+++ b/editors/code/src/commands/line_buffer.ts
@@ -0,0 +1,16 @@
+export class LineBuffer {
+    private outBuffer: string = '';
+
+    public processOutput(chunk: string, cb: (line: string) => void) {
+        this.outBuffer += chunk;
+        let eolIndex = this.outBuffer.indexOf('\n');
+        while (eolIndex >= 0) {
+            // line includes the EOL
+            const line = this.outBuffer.slice(0, eolIndex + 1);
+            cb(line);
+            this.outBuffer = this.outBuffer.slice(eolIndex + 1);
+
+            eolIndex = this.outBuffer.indexOf('\n');
+        }
+    }
+}
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
index 4187ef4d1..3589edcee 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -1,9 +1,11 @@
 import * as child_process from 'child_process';
+
 import * as util from 'util';
 import * as vscode from 'vscode';
 import * as lc from 'vscode-languageclient';
 
 import { Server } from '../server';
+import { CargoWatchProvider } from './cargo_watch';
 
 interface RunnablesParams {
     textDocument: lc.TextDocumentIdentifier;
@@ -127,37 +129,19 @@ export async function handleSingle(runnable: Runnable) {
     return vscode.tasks.executeTask(task);
 }
 
-export const autoCargoWatchTask: vscode.Task = {
-    name: 'cargo watch',
-    source: 'rust-analyzer',
-    definition: {
-        type: 'watch'
-    },
-    execution: new vscode.ShellExecution('cargo', ['watch'], { cwd: '.' }),
-
-    isBackground: true,
-    problemMatchers: ['$rustc-watch'],
-    presentationOptions: {
-        clear: true
-    },
-    // Not yet exposed in the vscode.d.ts
-    // https://github.com/Microsoft/vscode/blob/ea7c31d770e04b51d586b0d3944f3a7feb03afb9/src/vs/workbench/contrib/tasks/common/tasks.ts#L444-L456
-    runOptions: ({
-        runOn: 2 // RunOnOptions.folderOpen
-    } as unknown) as vscode.RunOptions
-};
-
 /**
  * Interactively asks the user whether we should run `cargo check` in order to
  * provide inline diagnostics; the user is met with a series of dialog boxes
  * that, when accepted, allow us to `cargo install cargo-watch` and then run it.
  */
-export async function interactivelyStartCargoWatch() {
-    if (Server.config.enableCargoWatchOnStartup === 'disabled') {
+export async function interactivelyStartCargoWatch(
+    context: vscode.ExtensionContext
+) {
+    if (Server.config.cargoWatchOptions.enableOnStartup === 'disabled') {
         return;
     }
 
-    if (Server.config.enableCargoWatchOnStartup === 'ask') {
+    if (Server.config.cargoWatchOptions.enableOnStartup === 'ask') {
         const watch = await vscode.window.showInformationMessage(
             'Start watching changes with cargo? (Executes `cargo watch`, provides inline diagnostics)',
             'yes',
@@ -212,5 +196,6 @@ export async function interactivelyStartCargoWatch() {
         }
     }
 
-    vscode.tasks.executeTask(autoCargoWatchTask);
+    const validater = new CargoWatchProvider();
+    validater.activate(context.subscriptions);
 }
diff --git a/editors/code/src/commands/watch_status.ts b/editors/code/src/commands/watch_status.ts
new file mode 100644
index 000000000..86ae821de
--- /dev/null
+++ b/editors/code/src/commands/watch_status.ts
@@ -0,0 +1,51 @@
+import * as vscode from 'vscode';
+
+const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+export class StatusDisplay {
+    public packageName?: string;
+
+    private i = 0;
+    private statusBarItem: vscode.StatusBarItem;
+    private timer?: NodeJS.Timeout;
+
+    constructor(subscriptions: vscode.Disposable[]) {
+        this.statusBarItem = vscode.window.createStatusBarItem(
+            vscode.StatusBarAlignment.Left,
+            10
+        );
+        subscriptions.push(this.statusBarItem);
+        this.statusBarItem.hide();
+    }
+
+    public show() {
+        this.packageName = undefined;
+
+        this.timer =
+            this.timer ||
+            setInterval(() => {
+                if (this.packageName) {
+                    this.statusBarItem!.text = `cargo check [${
+                        this.packageName
+                    }] ${this.frame()}`;
+                } else {
+                    this.statusBarItem!.text = `cargo check ${this.frame()}`;
+                }
+            }, 300);
+
+        this.statusBarItem!.show();
+    }
+
+    public hide() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = undefined;
+        }
+
+        this.statusBarItem!.hide();
+    }
+
+    private frame() {
+        return spinnerFrames[(this.i = ++this.i % spinnerFrames.length)];
+    }
+}
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 420589068..481a5e5f1 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -4,14 +4,25 @@ import { Server } from './server';
 
 const RA_LSP_DEBUG = process.env.__RA_LSP_SERVER_DEBUG;
 
-export type CargoWatchOptions = 'ask' | 'enabled' | 'disabled';
+export type CargoWatchStartupOptions = 'ask' | 'enabled' | 'disabled';
+export type CargoWatchTraceOptions = 'off' | 'error' | 'verbose';
+
+export interface CargoWatchOptions {
+    enableOnStartup: CargoWatchStartupOptions;
+    checkArguments: string;
+    trace: CargoWatchTraceOptions;
+}
 
 export class Config {
     public highlightingOn = true;
     public enableEnhancedTyping = true;
     public raLspServerPath = RA_LSP_DEBUG || 'ra_lsp_server';
     public showWorkspaceLoadedNotification = true;
-    public enableCargoWatchOnStartup: CargoWatchOptions = 'ask';
+    public cargoWatchOptions: CargoWatchOptions = {
+        enableOnStartup: 'ask',
+        trace: 'off',
+        checkArguments: ''
+    };
 
     private prevEnhancedTyping: null | boolean = null;
 
@@ -73,9 +84,22 @@ export class Config {
         }
 
         if (config.has('enableCargoWatchOnStartup')) {
-            this.enableCargoWatchOnStartup = config.get<CargoWatchOptions>(
-                'enableCargoWatchOnStartup',
-                'ask'
+            this.cargoWatchOptions.enableOnStartup = config.get<
+                CargoWatchStartupOptions
+            >('enableCargoWatchOnStartup', 'ask');
+        }
+
+        if (config.has('trace.cargo-watch')) {
+            this.cargoWatchOptions.trace = config.get<CargoWatchTraceOptions>(
+                'trace.cargo-watch',
+                'off'
+            );
+        }
+
+        if (config.has('cargo-watch.check-arguments')) {
+            this.cargoWatchOptions.checkArguments = config.get<string>(
+                'cargo-watch.check-arguments',
+                ''
             );
         }
     }
diff --git a/editors/code/src/extension.ts b/editors/code/src/extension.ts
index 2e13c87de..ef83c0b8b 100644
--- a/editors/code/src/extension.ts
+++ b/editors/code/src/extension.ts
@@ -121,7 +121,7 @@ export function activate(context: vscode.ExtensionContext) {
     );
 
     // Executing `cargo watch` provides us with inline diagnostics on save
-    interactivelyStartCargoWatch();
+    interactivelyStartCargoWatch(context);
 
     // Start the language server, finally!
     Server.start(allNotifications);
diff --git a/editors/code/src/utils/processes.ts b/editors/code/src/utils/processes.ts
new file mode 100644
index 000000000..da8be9eb1
--- /dev/null
+++ b/editors/code/src/utils/processes.ts
@@ -0,0 +1,51 @@
+'use strict';
+
+import * as cp from 'child_process';
+import ChildProcess = cp.ChildProcess;
+
+import { join } from 'path';
+
+const isWindows = process.platform === 'win32';
+const isMacintosh = process.platform === 'darwin';
+const isLinux = process.platform === 'linux';
+
+// this is very complex, but is basically copy-pased from VSCode implementation here:
+// https://github.com/Microsoft/vscode-languageserver-node/blob/dbfd37e35953ad0ee14c4eeced8cfbc41697b47e/client/src/utils/processes.ts#L15
+
+// And see discussion at
+// https://github.com/rust-analyzer/rust-analyzer/pull/1079#issuecomment-478908109
+
+export function terminate(process: ChildProcess, cwd?: string): boolean {
+    if (isWindows) {
+        try {
+            // This we run in Atom execFileSync is available.
+            // Ignore stderr since this is otherwise piped to parent.stderr
+            // which might be already closed.
+            const options: any = {
+                stdio: ['pipe', 'pipe', 'ignore']
+            };
+            if (cwd) {
+                options.cwd = cwd;
+            }
+            cp.execFileSync(
+                'taskkill',
+                ['/T', '/F', '/PID', process.pid.toString()],
+                options
+            );
+            return true;
+        } catch (err) {
+            return false;
+        }
+    } else if (isLinux || isMacintosh) {
+        try {
+            const cmd = join(__dirname, 'terminateProcess.sh');
+            const result = cp.spawnSync(cmd, [process.pid.toString()]);
+            return result.error ? false : true;
+        } catch (err) {
+            return false;
+        }
+    } else {
+        process.kill('SIGKILL');
+        return true;
+    }
+}
diff --git a/editors/code/src/utils/terminateProcess.sh b/editors/code/src/utils/terminateProcess.sh
new file mode 100644
index 000000000..2ec9e1c2e
--- /dev/null
+++ b/editors/code/src/utils/terminateProcess.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+
+terminateTree() {
+    for cpid in $(pgrep -P $1); do
+        terminateTree $cpid
+    done
+    kill -9 $1 > /dev/null 2>&1
+}
+
+for pid in $*; do
+    terminateTree $pid
+done
\ No newline at end of file