8 files changed, 300 insertions, 0 deletions

diff --git a/editors/code/src/commands/apply_source_change.ts b/editors/code/src/commands/apply_source_change.ts
new file mode 100644
index 000000000..67765e5a3
--- /dev/null
+++ b/editors/code/src/commands/apply_source_change.ts
@@ -0,0 +1,58 @@
+import * as vscode from 'vscode';
+import * as lc from 'vscode-languageclient';
+
+import { Server } from '../server';
+
+interface FileSystemEdit {
+    type: string;
+    uri?: string;
+    src?: string;
+    dst?: string;
+}
+
+export interface SourceChange {
+    label: string;
+    sourceFileEdits: lc.TextDocumentEdit[];
+    fileSystemEdits: FileSystemEdit[];
+    cursorPosition?: lc.TextDocumentPositionParams;
+}
+
+export async function handle(change: SourceChange) {
+    const wsEdit = new vscode.WorkspaceEdit();
+    for (const sourceEdit of change.sourceFileEdits) {
+        const uri = Server.client.protocol2CodeConverter.asUri(sourceEdit.textDocument.uri);
+        const edits = Server.client.protocol2CodeConverter.asTextEdits(sourceEdit.edits);
+        wsEdit.set(uri, edits);
+    }
+    let created;
+    let moved;
+    for (const fsEdit of change.fileSystemEdits) {
+        switch (fsEdit.type) {
+            case 'createFile':
+                const uri = vscode.Uri.parse(fsEdit.uri!);
+                wsEdit.createFile(uri);
+                created = uri;
+                break;
+            case 'moveFile':
+                const src = vscode.Uri.parse(fsEdit.src!);
+                const dst = vscode.Uri.parse(fsEdit.dst!);
+                wsEdit.renameFile(src, dst);
+                moved = dst;
+                break;
+        }
+    }
+    const toOpen = created || moved;
+    const toReveal = change.cursorPosition;
+    await vscode.workspace.applyEdit(wsEdit);
+    if (toOpen) {
+        const doc = await vscode.workspace.openTextDocument(toOpen);
+        await vscode.window.showTextDocument(doc);
+    } else if (toReveal) {
+        const uri = Server.client.protocol2CodeConverter.asUri(toReveal.textDocument.uri);
+        const position = Server.client.protocol2CodeConverter.asPosition(toReveal.position);
+        const editor = vscode.window.activeTextEditor;
+        if (!editor || editor.document.uri.toString() !== uri.toString()) { return; }
+        if (!editor.selection.isEmpty) { return; }
+        editor!.selection = new vscode.Selection(position, position);
+    }
+}
diff --git a/editors/code/src/commands/extend_selection.ts b/editors/code/src/commands/extend_selection.ts
new file mode 100644
index 000000000..cdc3d10fb
--- /dev/null
+++ b/editors/code/src/commands/extend_selection.ts
@@ -0,0 +1,29 @@
+import * as vscode from 'vscode';
+
+import { Range, TextDocumentIdentifier } from 'vscode-languageclient';
+import { Server } from '../server';
+
+interface ExtendSelectionParams {
+    textDocument: TextDocumentIdentifier;
+    selections: Range[];
+}
+
+interface ExtendSelectionResult {
+    selections: Range[];
+}
+
+export async function handle() {
+    const editor = vscode.window.activeTextEditor;
+    if (editor == null || editor.document.languageId !== 'rust') { return; }
+    const request: ExtendSelectionParams = {
+        selections: editor.selections.map((s) => {
+            return Server.client.code2ProtocolConverter.asRange(s);
+        }),
+        textDocument: { uri: editor.document.uri.toString() },
+    };
+    const response = await Server.client.sendRequest<ExtendSelectionResult>('m/extendSelection', request);
+    editor.selections = response.selections.map((range: Range) => {
+        const r = Server.client.protocol2CodeConverter.asRange(range);
+        return new vscode.Selection(r.start, r.end);
+    });
+}
diff --git a/editors/code/src/commands/index.ts b/editors/code/src/commands/index.ts
new file mode 100644
index 000000000..dfdcd6454
--- /dev/null
+++ b/editors/code/src/commands/index.ts
@@ -0,0 +1,17 @@
+import * as applySourceChange from './apply_source_change';
+import * as extendSelection from './extend_selection';
+import * as joinLines from './join_lines';
+import * as matchingBrace from './matching_brace';
+import * as parentModule from './parent_module';
+import * as runnables from './runnables';
+import * as syntaxTree from './syntaxTree';
+
+export {
+    applySourceChange,
+    extendSelection,
+    joinLines,
+    matchingBrace,
+    parentModule,
+    runnables,
+    syntaxTree,
+};
diff --git a/editors/code/src/commands/join_lines.ts b/editors/code/src/commands/join_lines.ts
new file mode 100644
index 000000000..526b698cc
--- /dev/null
+++ b/editors/code/src/commands/join_lines.ts
@@ -0,0 +1,21 @@
+import * as vscode from 'vscode';
+
+import { Range, TextDocumentIdentifier } from 'vscode-languageclient';
+import { Server } from '../server';
+import { handle as applySourceChange, SourceChange } from './apply_source_change';
+
+interface JoinLinesParams {
+    textDocument: TextDocumentIdentifier;
+    range: Range;
+}
+
+export async function handle() {
+    const editor = vscode.window.activeTextEditor;
+    if (editor == null || editor.document.languageId !== 'rust') { return; }
+    const request: JoinLinesParams = {
+        range: Server.client.code2ProtocolConverter.asRange(editor.selection),
+        textDocument: { uri: editor.document.uri.toString() },
+    };
+    const change = await Server.client.sendRequest<SourceChange>('m/joinLines', request);
+    await applySourceChange(change);
+}
diff --git a/editors/code/src/commands/matching_brace.ts b/editors/code/src/commands/matching_brace.ts
new file mode 100644
index 000000000..a80446a8f
--- /dev/null
+++ b/editors/code/src/commands/matching_brace.ts
@@ -0,0 +1,27 @@
+import * as vscode from 'vscode';
+
+import { Position, TextDocumentIdentifier } from 'vscode-languageclient';
+import { Server } from '../server';
+
+interface FindMatchingBraceParams {
+    textDocument: TextDocumentIdentifier;
+    offsets: Position[];
+}
+
+export async function handle() {
+    const editor = vscode.window.activeTextEditor;
+    if (editor == null || editor.document.languageId !== 'rust') { return; }
+    const request: FindMatchingBraceParams = {
+        textDocument: { uri: editor.document.uri.toString() },
+        offsets: editor.selections.map((s) => {
+            return Server.client.code2ProtocolConverter.asPosition(s.active);
+        }),
+    };
+    const response = await Server.client.sendRequest<Position[]>('m/findMatchingBrace', request);
+    editor.selections = editor.selections.map((sel, idx) => {
+        const active = Server.client.protocol2CodeConverter.asPosition(response[idx]);
+        const anchor = sel.isEmpty ? active : sel.anchor;
+        return new vscode.Selection(anchor, active);
+    });
+    editor.revealRange(editor.selection);
+}
diff --git a/editors/code/src/commands/parent_module.ts b/editors/code/src/commands/parent_module.ts
new file mode 100644
index 000000000..d66fb3026
--- /dev/null
+++ b/editors/code/src/commands/parent_module.ts
@@ -0,0 +1,22 @@
+import * as vscode from 'vscode';
+
+import { Location, TextDocumentIdentifier } from 'vscode-languageclient';
+import { Server } from '../server';
+
+export async function handle() {
+    const editor = vscode.window.activeTextEditor;
+    if (editor == null || editor.document.languageId !== 'rust') { return; }
+    const request: TextDocumentIdentifier = {
+        uri: editor.document.uri.toString(),
+    };
+    const response = await Server.client.sendRequest<Location[]>('m/parentModule', request);
+    const loc = response[0];
+    if (loc == null) { return; }
+    const uri = Server.client.protocol2CodeConverter.asUri(loc.uri);
+    const range = Server.client.protocol2CodeConverter.asRange(loc.range);
+
+    const doc = await vscode.workspace.openTextDocument(uri);
+    const e = await vscode.window.showTextDocument(doc);
+    e.selection = new vscode.Selection(range.start, range.start);
+    e.revealRange(range, vscode.TextEditorRevealType.InCenter);
+}
diff --git a/editors/code/src/commands/runnables.ts b/editors/code/src/commands/runnables.ts
new file mode 100644
index 000000000..40f590dce
--- /dev/null
+++ b/editors/code/src/commands/runnables.ts
@@ -0,0 +1,88 @@
+import * as vscode from 'vscode';
+import * as lc from 'vscode-languageclient';
+import { Server } from '../server';
+
+interface RunnablesParams {
+    textDocument: lc.TextDocumentIdentifier;
+    position?: lc.Position;
+}
+
+interface Runnable {
+    range: lc.Range;
+    label: string;
+    bin: string;
+    args: string[];
+    env: { [index: string]: string };
+}
+
+class RunnableQuickPick implements vscode.QuickPickItem {
+    public label: string;
+    public description?: string | undefined;
+    public detail?: string | undefined;
+    public picked?: boolean | undefined;
+
+    constructor(public runnable: Runnable) {
+        this.label = runnable.label;
+    }
+}
+
+interface CargoTaskDefinition extends vscode.TaskDefinition {
+    type: 'cargo';
+    label: string;
+    command: string;
+    args: string[];
+    env?: { [key: string]: string };
+}
+
+function createTask(spec: Runnable): vscode.Task {
+    const TASK_SOURCE = 'Rust';
+    const definition: CargoTaskDefinition = {
+        type: 'cargo',
+        label: 'cargo',
+        command: spec.bin,
+        args: spec.args,
+        env: spec.env,
+    };
+
+    const execCmd = `${definition.command} ${definition.args.join(' ')}`;
+    const execOption: vscode.ShellExecutionOptions = {
+        cwd: '.',
+        env: definition.env,
+    };
+    const exec = new vscode.ShellExecution(`clear; ${execCmd}`, execOption);
+
+    const f = vscode.workspace.workspaceFolders![0];
+    const t = new vscode.Task(definition, f, definition.label, TASK_SOURCE, exec, ['$rustc']);
+    return t;
+}
+
+let prevRunnable: RunnableQuickPick | undefined;
+export async function handle() {
+    const editor = vscode.window.activeTextEditor;
+    if (editor == null || editor.document.languageId !== 'rust') { return; }
+    const textDocument: lc.TextDocumentIdentifier = {
+        uri: editor.document.uri.toString(),
+    };
+    const params: RunnablesParams = {
+        textDocument,
+        position: Server.client.code2ProtocolConverter.asPosition(editor.selection.active),
+    };
+    const runnables = await Server.client.sendRequest<Runnable[]>('m/runnables', params);
+    const items: RunnableQuickPick[] = [];
+    if (prevRunnable) {
+        items.push(prevRunnable);
+    }
+    for (const r of runnables) {
+        if (prevRunnable && JSON.stringify(prevRunnable.runnable) === JSON.stringify(r)) {
+            continue;
+        }
+        items.push(new RunnableQuickPick(r));
+    }
+    const item = await vscode.window.showQuickPick(items);
+    if (item) {
+        item.detail = 'rerun';
+        prevRunnable = item;
+        const task = createTask(item.runnable);
+        return await vscode.tasks.executeTask(task);
+    }
+}
diff --git a/editors/code/src/commands/syntaxTree.ts b/editors/code/src/commands/syntaxTree.ts
new file mode 100644
index 000000000..dcb721eee
--- /dev/null
+++ b/editors/code/src/commands/syntaxTree.ts
@@ -0,0 +1,38 @@
+import * as vscode from 'vscode';
+import { TextDocumentIdentifier } from 'vscode-languageclient';
+
+import { Server } from '../server';
+
+export const syntaxTreeUri = vscode.Uri.parse('ra-lsp://syntaxtree');
+
+export class TextDocumentContentProvider implements vscode.TextDocumentContentProvider {
+    public eventEmitter = new vscode.EventEmitter<vscode.Uri>();
+    public syntaxTree: string = 'Not available';
+
+    public provideTextDocumentContent(uri: vscode.Uri): vscode.ProviderResult<string> {
+        const editor = vscode.window.activeTextEditor;
+        if (editor == null) { return ''; }
+        const request: SyntaxTreeParams = {
+            textDocument: { uri: editor.document.uri.toString() },
+        };
+        return Server.client.sendRequest<SyntaxTreeResult>('m/syntaxTree', request);
+    }
+
+    get onDidChange(): vscode.Event<vscode.Uri> {
+        return this.eventEmitter.event;
+    }
+}
+
+interface SyntaxTreeParams {
+    textDocument: TextDocumentIdentifier;
+}
+
+type SyntaxTreeResult = string;
+
+// Opens the virtual file that will show the syntax tree
+//
+// The contents of the file come from the `TextDocumentContentProvider`
+export async function handle() {
+    const document = await vscode.workspace.openTextDocument(syntaxTreeUri);
+    return vscode.window.showTextDocument(document, vscode.ViewColumn.Two, true);
+}