Apply tslint suggestions, round one

7 files changed, 130 insertions, 130 deletions

diff --git a/editors/code/src/commands/apply_source_change.ts b/editors/code/src/commands/apply_source_change.ts
index dcbbb2b0984..f011cbe12e9 100644
--- a/editors/code/src/commands/apply_source_change.ts
+++ b/editors/code/src/commands/apply_source_change.ts
@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient'
+import * as lc from 'vscode-languageclient';
 
 import { Server } from '../server';
 
@@ -11,48 +11,48 @@ interface FileSystemEdit {
 }
 
 export interface SourceChange {
-    label: string,
-    sourceFileEdits: lc.TextDocumentEdit[],
-    fileSystemEdits: FileSystemEdit[],
-    cursorPosition?: lc.TextDocumentPositionParams,
+    label: string;
+    sourceFileEdits: lc.TextDocumentEdit[];
+    fileSystemEdits: FileSystemEdit[];
+    cursorPosition?: lc.TextDocumentPositionParams;
 }
 
 export async function handle(change: SourceChange) {
-    console.log(`applySOurceChange ${JSON.stringify(change)}`)
-    let wsEdit = new vscode.WorkspaceEdit()
-    for (let sourceEdit of change.sourceFileEdits) {
-        let uri = Server.client.protocol2CodeConverter.asUri(sourceEdit.textDocument.uri)
-        let edits = Server.client.protocol2CodeConverter.asTextEdits(sourceEdit.edits)
-        wsEdit.set(uri, edits)
+    console.log(`applySOurceChange ${JSON.stringify(change)}`);
+    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 (let fsEdit of change.fileSystemEdits) {
-        if (fsEdit.type == "createFile") {
-            let uri = vscode.Uri.parse(fsEdit.uri!)
-            wsEdit.createFile(uri)
-            created = uri
-        } else if (fsEdit.type == "moveFile") {
-            let src = vscode.Uri.parse(fsEdit.src!)
-            let dst = vscode.Uri.parse(fsEdit.dst!)
-            wsEdit.renameFile(src, dst)
-            moved = dst
+    for (const fsEdit of change.fileSystemEdits) {
+        if (fsEdit.type == 'createFile') {
+            const uri = vscode.Uri.parse(fsEdit.uri!);
+            wsEdit.createFile(uri);
+            created = uri;
+        } else if (fsEdit.type == 'moveFile') {
+            const src = vscode.Uri.parse(fsEdit.src!);
+            const dst = vscode.Uri.parse(fsEdit.dst!);
+            wsEdit.renameFile(src, dst);
+            moved = dst;
         } else {
-            console.error(`unknown op: ${JSON.stringify(fsEdit)}`)
+            console.error(`unknown op: ${JSON.stringify(fsEdit)}`);
         }
     }
-    let toOpen = created || moved
-    let toReveal = change.cursorPosition
-    await vscode.workspace.applyEdit(wsEdit)
+    const toOpen = created || moved;
+    const toReveal = change.cursorPosition;
+    await vscode.workspace.applyEdit(wsEdit);
     if (toOpen) {
-        let doc = await vscode.workspace.openTextDocument(toOpen)
-        await vscode.window.showTextDocument(doc)
+        const doc = await vscode.workspace.openTextDocument(toOpen);
+        await vscode.window.showTextDocument(doc);
     } else if (toReveal) {
-        let uri = Server.client.protocol2CodeConverter.asUri(toReveal.textDocument.uri)
-        let position = Server.client.protocol2CodeConverter.asPosition(toReveal.position)
-        let 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)
+        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
index b90828ba9ba..b722ac17229 100644
--- a/editors/code/src/commands/extend_selection.ts
+++ b/editors/code/src/commands/extend_selection.ts
@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 
-import { TextDocumentIdentifier, Range } from "vscode-languageclient";
+import { Range, TextDocumentIdentifier } from 'vscode-languageclient';
 import { Server } from '../server';
 
 interface ExtendSelectionParams {
@@ -13,17 +13,17 @@ interface ExtendSelectionResult {
 }
 
 export async function handle() {
-    let editor = vscode.window.activeTextEditor
-    if (editor == null || editor.document.languageId != "rust") return
-    let request: ExtendSelectionParams = {
-        textDocument: { uri: editor.document.uri.toString() },
+    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)
-        })
-    }
-    let response = await Server.client.sendRequest<ExtendSelectionResult>("m/extendSelection", request)
+            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) => {
-        let r = Server.client.protocol2CodeConverter.asRange(range)
-        return new vscode.Selection(r.start, r.end)
-    })
+        const r = Server.client.protocol2CodeConverter.asRange(range);
+        return new vscode.Selection(r.start, r.end);
+    });
 }
diff --git a/editors/code/src/commands/join_lines.ts b/editors/code/src/commands/join_lines.ts
index 7ae7b9d7601..80ad4460ba1 100644
--- a/editors/code/src/commands/join_lines.ts
+++ b/editors/code/src/commands/join_lines.ts
@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 
-import { TextDocumentIdentifier, Range } from "vscode-languageclient";
+import { Range, TextDocumentIdentifier } from 'vscode-languageclient';
 import { Server } from '../server';
 import { handle as applySourceChange, SourceChange } from './apply_source_change';
 
@@ -10,12 +10,12 @@ interface JoinLinesParams {
 }
 
 export async function handle() {
-    let editor = vscode.window.activeTextEditor
-    if (editor == null || editor.document.languageId != "rust") return
-    let request: JoinLinesParams = {
-        textDocument: { uri: editor.document.uri.toString() },
+    const editor = vscode.window.activeTextEditor;
+    if (editor == null || editor.document.languageId != 'rust') { return; }
+    const request: JoinLinesParams = {
         range: Server.client.code2ProtocolConverter.asRange(editor.selection),
-    }
-    let change = await Server.client.sendRequest<SourceChange>("m/joinLines", request)
-    await applySourceChange(change)
+        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
index 572c15ce830..cf7f6bf8fac 100644
--- a/editors/code/src/commands/matching_brace.ts
+++ b/editors/code/src/commands/matching_brace.ts
@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 
-import { TextDocumentIdentifier, Position } from "vscode-languageclient";
+import { Position, TextDocumentIdentifier } from 'vscode-languageclient';
 import { Server } from '../server';
 
 interface FindMatchingBraceParams {
@@ -9,19 +9,19 @@ interface FindMatchingBraceParams {
 }
 
 export async function handle() {
-    let editor = vscode.window.activeTextEditor
-    if (editor == null || editor.document.languageId != "rust") return
-    let request: FindMatchingBraceParams = {
+    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)
-        })
-    }
-    let response = await Server.client.sendRequest<Position[]>("m/findMatchingBrace", request)
+            return Server.client.code2ProtocolConverter.asPosition(s.active);
+        }),
+    };
+    const response = await Server.client.sendRequest<Position[]>('m/findMatchingBrace', request);
     editor.selections = editor.selections.map((sel, idx) => {
-        let active = Server.client.protocol2CodeConverter.asPosition(response[idx])
-        let anchor = sel.isEmpty ? active : sel.anchor
-        return new vscode.Selection(anchor, active)
-    })
-    editor.revealRange(editor.selection)
-};
+        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
index dae60bfb4a3..7d413c27a65 100644
--- a/editors/code/src/commands/parent_module.ts
+++ b/editors/code/src/commands/parent_module.ts
@@ -1,22 +1,22 @@
 import * as vscode from 'vscode';
 
-import { TextDocumentIdentifier, Location } from "vscode-languageclient";
+import { Location, TextDocumentIdentifier } from 'vscode-languageclient';
 import { Server } from '../server';
 
 export async function handle() {
-    let editor = vscode.window.activeTextEditor
-    if (editor == null || editor.document.languageId != "rust") return
-    let request: TextDocumentIdentifier = {
-        uri: editor.document.uri.toString()
-    }
-    let response = await Server.client.sendRequest<Location[]>("m/parentModule", request)
-    let loc = response[0]
-    if (loc == null) return
-    let uri = Server.client.protocol2CodeConverter.asUri(loc.uri)
-    let range = Server.client.protocol2CodeConverter.asRange(loc.range)
+    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);
 
-    let doc = await vscode.workspace.openTextDocument(uri)
-    let e = await vscode.window.showTextDocument(doc)
-    e.selection = new vscode.Selection(range.start, range.start)
-    e.revealRange(range, vscode.TextEditorRevealType.InCenter)
+    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
index 45c16497dbe..37db6ea10ac 100644
--- a/editors/code/src/commands/runnables.ts
+++ b/editors/code/src/commands/runnables.ts
@@ -1,10 +1,10 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient'
+import * as lc from 'vscode-languageclient';
 import { Server } from '../server';
 
 interface RunnablesParams {
-    textDocument: lc.TextDocumentIdentifier,
-    position?: lc.Position,
+    textDocument: lc.TextDocumentIdentifier;
+    position?: lc.Position;
 }
 
 interface Runnable {
@@ -12,17 +12,17 @@ interface Runnable {
     label: string;
     bin: string;
     args: string[];
-    env: { [index: string]: string },
+    env: { [index: string]: string };
 }
 
 class RunnableQuickPick implements vscode.QuickPickItem {
-    label: string;
-    description?: string | undefined;
-    detail?: string | undefined;
-    picked?: boolean | undefined;
+    public label: string;
+    public description?: string | undefined;
+    public detail?: string | undefined;
+    public picked?: boolean | undefined;
 
     constructor(public runnable: Runnable) {
-        this.label = runnable.label
+        this.label = runnable.label;
     }
 }
 
@@ -30,59 +30,59 @@ interface CargoTaskDefinition extends vscode.TaskDefinition {
     type: 'cargo';
     label: string;
     command: string;
-    args: Array<string>;
+    args: string[];
     env?: { [key: string]: string };
 }
 
 function createTask(spec: Runnable): vscode.Task {
     const TASK_SOURCE = 'Rust';
-    let definition: CargoTaskDefinition = {
+    const definition: CargoTaskDefinition = {
         type: 'cargo',
         label: 'cargo',
         command: spec.bin,
         args: spec.args,
-        env: spec.env
-    }
+        env: spec.env,
+    };
 
-    let execCmd = `${definition.command} ${definition.args.join(' ')}`;
-    let execOption: vscode.ShellExecutionOptions = {
+    const execCmd = `${definition.command} ${definition.args.join(' ')}`;
+    const execOption: vscode.ShellExecutionOptions = {
         cwd: '.',
         env: definition.env,
     };
-    let exec = new vscode.ShellExecution(`clear; ${execCmd}`, execOption);
+    const exec = new vscode.ShellExecution(`clear; ${execCmd}`, execOption);
 
-    let f = vscode.workspace.workspaceFolders![0]
-    let t = new vscode.Task(definition, f, definition.label, TASK_SOURCE, exec, ['$rustc']);
+    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 = undefined
+let prevRunnable: RunnableQuickPick | undefined;
 export async function handle() {
-    let editor = vscode.window.activeTextEditor
-    if (editor == null || editor.document.languageId != "rust") return
-    let textDocument: lc.TextDocumentIdentifier = {
-        uri: editor.document.uri.toString()
-    }
-    let params: RunnablesParams = {
+    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)
-    }
-    let runnables = await Server.client.sendRequest<Runnable[]>('m/runnables', params)
-    let items: RunnableQuickPick[] = []
+        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)
+        items.push(prevRunnable);
     }
-    for (let r of runnables) {
+    for (const r of runnables) {
         if (prevRunnable && JSON.stringify(prevRunnable.runnable) == JSON.stringify(r)) {
-            continue
+            continue;
         }
-        items.push(new RunnableQuickPick(r))
+        items.push(new RunnableQuickPick(r));
     }
-    let item = await vscode.window.showQuickPick(items)
+    const item = await vscode.window.showQuickPick(items);
     if (item) {
-        item.detail = "rerun"
-        prevRunnable = item
-        let task = createTask(item.runnable)
-        return await vscode.tasks.executeTask(task)
+        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
index d5daa9302c6..dcb721eee59 100644
--- a/editors/code/src/commands/syntaxTree.ts
+++ b/editors/code/src/commands/syntaxTree.ts
@@ -6,20 +6,20 @@ 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 eventEmitter = new vscode.EventEmitter<vscode.Uri>();
+    public syntaxTree: string = 'Not available';
 
     public provideTextDocumentContent(uri: vscode.Uri): vscode.ProviderResult<string> {
-        let editor = vscode.window.activeTextEditor;
-        if (editor == null) return ""
-        let request: SyntaxTreeParams = {
-            textDocument: { uri: editor.document.uri.toString() }
+        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);
+        return Server.client.sendRequest<SyntaxTreeResult>('m/syntaxTree', request);
     }
 
     get onDidChange(): vscode.Event<vscode.Uri> {
-        return this.eventEmitter.event
+        return this.eventEmitter.event;
     }
 }
 
@@ -33,6 +33,6 @@ type SyntaxTreeResult = string;
 //
 // The contents of the file come from the `TextDocumentContentProvider`
 export async function handle() {
-    let document = await vscode.workspace.openTextDocument(syntaxTreeUri)
-    return vscode.window.showTextDocument(document, vscode.ViewColumn.Two, true)
+    const document = await vscode.workspace.openTextDocument(syntaxTreeUri);
+    return vscode.window.showTextDocument(document, vscode.ViewColumn.Two, true);
 }