Apply tslint suggestions, round one

editors/code/src/commands.ts

@@ -13,5 +13,5 @@ export {
     matchingBrace,
     parentModule,
     runnables,
-    syntaxTree
+    syntaxTree,
-}
+};

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,
+    label: string;
-    sourceFileEdits: lc.TextDocumentEdit[],
+    sourceFileEdits: lc.TextDocumentEdit[];
-    fileSystemEdits: FileSystemEdit[],
+    fileSystemEdits: FileSystemEdit[];
-    cursorPosition?: lc.TextDocumentPositionParams,
+    cursorPosition?: lc.TextDocumentPositionParams;
 }
 
 export async function handle(change: SourceChange) {
-    console.log(`applySOurceChange ${JSON.stringify(change)}`)
+    console.log(`applySOurceChange ${JSON.stringify(change)}`);
-    let wsEdit = new vscode.WorkspaceEdit()
+    const wsEdit = new vscode.WorkspaceEdit();
-    for (let sourceEdit of change.sourceFileEdits) {
+    for (const sourceEdit of change.sourceFileEdits) {
-        let uri = Server.client.protocol2CodeConverter.asUri(sourceEdit.textDocument.uri)
+        const uri = Server.client.protocol2CodeConverter.asUri(sourceEdit.textDocument.uri);
-        let edits = Server.client.protocol2CodeConverter.asTextEdits(sourceEdit.edits)
+        const edits = Server.client.protocol2CodeConverter.asTextEdits(sourceEdit.edits);
-        wsEdit.set(uri, edits)
+        wsEdit.set(uri, edits);
     }
     let created;
     let moved;
-    for (let fsEdit of change.fileSystemEdits) {
+    for (const fsEdit of change.fileSystemEdits) {
-        if (fsEdit.type == "createFile") {
+        if (fsEdit.type == 'createFile') {
-            let uri = vscode.Uri.parse(fsEdit.uri!)
+            const uri = vscode.Uri.parse(fsEdit.uri!);
-            wsEdit.createFile(uri)
+            wsEdit.createFile(uri);
-            created = uri
+            created = uri;
-        } else if (fsEdit.type == "moveFile") {
+        } else if (fsEdit.type == 'moveFile') {
-            let src = vscode.Uri.parse(fsEdit.src!)
+            const src = vscode.Uri.parse(fsEdit.src!);
-            let dst = vscode.Uri.parse(fsEdit.dst!)
+            const dst = vscode.Uri.parse(fsEdit.dst!);
-            wsEdit.renameFile(src, dst)
+            wsEdit.renameFile(src, dst);
-            moved = dst
+            moved = dst;
         } else {
-            console.error(`unknown op: ${JSON.stringify(fsEdit)}`)
+            console.error(`unknown op: ${JSON.stringify(fsEdit)}`);
         }
     }
-    let toOpen = created || moved
+    const toOpen = created || moved;
-    let toReveal = change.cursorPosition
+    const toReveal = change.cursorPosition;
-    await vscode.workspace.applyEdit(wsEdit)
+    await vscode.workspace.applyEdit(wsEdit);
     if (toOpen) {
-        let doc = await vscode.workspace.openTextDocument(toOpen)
+        const doc = await vscode.workspace.openTextDocument(toOpen);
-        await vscode.window.showTextDocument(doc)
+        await vscode.window.showTextDocument(doc);
     } else if (toReveal) {
-        let uri = Server.client.protocol2CodeConverter.asUri(toReveal.textDocument.uri)
+        const uri = Server.client.protocol2CodeConverter.asUri(toReveal.textDocument.uri);
-        let position = Server.client.protocol2CodeConverter.asPosition(toReveal.position)
+        const position = Server.client.protocol2CodeConverter.asPosition(toReveal.position);
-        let editor = vscode.window.activeTextEditor;
+        const editor = vscode.window.activeTextEditor;
-        if (!editor || editor.document.uri.toString() != uri.toString()) return
+        if (!editor || editor.document.uri.toString() != uri.toString()) { return; }
-        if (!editor.selection.isEmpty) return
+        if (!editor.selection.isEmpty) { return; }
-        editor!.selection = new vscode.Selection(position, position)
+        editor!.selection = new vscode.Selection(position, position);
     }
 }

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
+    const editor = vscode.window.activeTextEditor;
-    if (editor == null || editor.document.languageId != "rust") return
+    if (editor == null || editor.document.languageId != 'rust') { return; }
-    let request: ExtendSelectionParams = {
+    const request: ExtendSelectionParams = {
-        textDocument: { uri: editor.document.uri.toString() },
         selections: editor.selections.map((s) => {
-            return Server.client.code2ProtocolConverter.asRange(s)
+            return Server.client.code2ProtocolConverter.asRange(s);
-        })
+        }),
-    }
+        textDocument: { uri: editor.document.uri.toString() },
-    let response = await Server.client.sendRequest<ExtendSelectionResult>("m/extendSelection", request)
+    };
+    const response = await Server.client.sendRequest<ExtendSelectionResult>('m/extendSelection', request);
     editor.selections = response.selections.map((range: Range) => {
-        let r = Server.client.protocol2CodeConverter.asRange(range)
+        const r = Server.client.protocol2CodeConverter.asRange(range);
-        return new vscode.Selection(r.start, r.end)
+        return new vscode.Selection(r.start, r.end);
-    })
+    });
 }

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
+    const editor = vscode.window.activeTextEditor;
-    if (editor == null || editor.document.languageId != "rust") return
+    if (editor == null || editor.document.languageId != 'rust') { return; }
-    let request: JoinLinesParams = {
+    const request: JoinLinesParams = {
-        textDocument: { uri: editor.document.uri.toString() },
         range: Server.client.code2ProtocolConverter.asRange(editor.selection),
-    }
+        textDocument: { uri: editor.document.uri.toString() },
-    let change = await Server.client.sendRequest<SourceChange>("m/joinLines", request)
+    };
-    await applySourceChange(change)
+    const change = await Server.client.sendRequest<SourceChange>('m/joinLines', request);
+    await applySourceChange(change);
 }

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
+    const editor = vscode.window.activeTextEditor;
-    if (editor == null || editor.document.languageId != "rust") return
+    if (editor == null || editor.document.languageId != 'rust') { return; }
-    let request: FindMatchingBraceParams = {
+    const request: FindMatchingBraceParams = {
         textDocument: { uri: editor.document.uri.toString() },
         offsets: editor.selections.map((s) => {
-            return Server.client.code2ProtocolConverter.asPosition(s.active)
+            return Server.client.code2ProtocolConverter.asPosition(s.active);
-        })
+        }),
-    }
+    };
-    let response = await Server.client.sendRequest<Position[]>("m/findMatchingBrace", request)
+    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])
+        const active = Server.client.protocol2CodeConverter.asPosition(response[idx]);
-        let anchor = sel.isEmpty ? active : sel.anchor
+        const anchor = sel.isEmpty ? active : sel.anchor;
-        return new vscode.Selection(anchor, active)
+        return new vscode.Selection(anchor, active);
-    })
+    });
-    editor.revealRange(editor.selection)
+    editor.revealRange(editor.selection);
-};
+}

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
+    const editor = vscode.window.activeTextEditor;
-    if (editor == null || editor.document.languageId != "rust") return
+    if (editor == null || editor.document.languageId != 'rust') { return; }
-    let request: TextDocumentIdentifier = {
+    const request: TextDocumentIdentifier = {
-        uri: editor.document.uri.toString()
+        uri: editor.document.uri.toString(),
-    }
+    };
-    let response = await Server.client.sendRequest<Location[]>("m/parentModule", request)
+    const response = await Server.client.sendRequest<Location[]>('m/parentModule', request);
-    let loc = response[0]
+    const loc = response[0];
-    if (loc == null) return
+    if (loc == null) { return; }
-    let uri = Server.client.protocol2CodeConverter.asUri(loc.uri)
+    const uri = Server.client.protocol2CodeConverter.asUri(loc.uri);
-    let range = Server.client.protocol2CodeConverter.asRange(loc.range)
+    const range = Server.client.protocol2CodeConverter.asRange(loc.range);
 
-    let doc = await vscode.workspace.openTextDocument(uri)
+    const doc = await vscode.workspace.openTextDocument(uri);
-    let e = await vscode.window.showTextDocument(doc)
+    const e = await vscode.window.showTextDocument(doc);
-    e.selection = new vscode.Selection(range.start, range.start)
+    e.selection = new vscode.Selection(range.start, range.start);
-    e.revealRange(range, vscode.TextEditorRevealType.InCenter)
+    e.revealRange(range, vscode.TextEditorRevealType.InCenter);
 }

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,
+    textDocument: lc.TextDocumentIdentifier;
-    position?: lc.Position,
+    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;
+    public label: string;
-    description?: string | undefined;
+    public description?: string | undefined;
-    detail?: string | undefined;
+    public detail?: string | undefined;
-    picked?: boolean | 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(' ')}`;
+    const execCmd = `${definition.command} ${definition.args.join(' ')}`;
-    let execOption: vscode.ShellExecutionOptions = {
+    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]
+    const f = vscode.workspace.workspaceFolders![0];
-    let t = new vscode.Task(definition, f, definition.label, TASK_SOURCE, exec, ['$rustc']);
+    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
+    const editor = vscode.window.activeTextEditor;
-    if (editor == null || editor.document.languageId != "rust") return
+    if (editor == null || editor.document.languageId != 'rust') { return; }
-    let textDocument: lc.TextDocumentIdentifier = {
+    const textDocument: lc.TextDocumentIdentifier = {
-        uri: editor.document.uri.toString()
+        uri: editor.document.uri.toString(),
-    }
+    };
-    let params: RunnablesParams = {
+    const params: RunnablesParams = {
         textDocument,
-        position: Server.client.code2ProtocolConverter.asPosition(editor.selection.active)
+        position: Server.client.code2ProtocolConverter.asPosition(editor.selection.active),
-    }
+    };
-    let runnables = await Server.client.sendRequest<Runnable[]>('m/runnables', params)
+    const runnables = await Server.client.sendRequest<Runnable[]>('m/runnables', params);
-    let items: RunnableQuickPick[] = []
+    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"
+        item.detail = 'rerun';
-        prevRunnable = item
+        prevRunnable = item;
-        let task = createTask(item.runnable)
+        const task = createTask(item.runnable);
-        return await vscode.tasks.executeTask(task)
+        return await vscode.tasks.executeTask(task);
     }
 }

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 eventEmitter = new vscode.EventEmitter<vscode.Uri>();
-    public syntaxTree: string = "Not available"
+    public syntaxTree: string = 'Not available';
 
     public provideTextDocumentContent(uri: vscode.Uri): vscode.ProviderResult<string> {
-        let editor = vscode.window.activeTextEditor;
+        const editor = vscode.window.activeTextEditor;
-        if (editor == null) return ""
+        if (editor == null) { return ''; }
-        let request: SyntaxTreeParams = {
+        const request: SyntaxTreeParams = {
-            textDocument: { uri: editor.document.uri.toString() }
+            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)
+    const document = await vscode.workspace.openTextDocument(syntaxTreeUri);
-    return vscode.window.showTextDocument(document, vscode.ViewColumn.Two, true)
+    return vscode.window.showTextDocument(document, vscode.ViewColumn.Two, true);
 }

editors/code/src/config.ts

@@ -0,0 +1,23 @@
+import * as vscode from 'vscode';
+
+import { Server } from './server';
+
+export class Config {
+    public highlightingOn = true;
+
+    constructor() {
+        vscode.workspace.onDidChangeConfiguration((_) => this.userConfigChanged());
+        this.userConfigChanged();
+    }
+
+    public userConfigChanged() {
+        const config = vscode.workspace.getConfiguration('ra-lsp');
+        if (config.has('highlightingOn')) {
+            this.highlightingOn = config.get('highlightingOn') as boolean;
+        }
+
+        if (!this.highlightingOn && Server) {
+            Server.highlighter.removeHighlights();
+        }
+    }
+}

editors/code/src/events.ts

@@ -1,7 +1,7 @@
-import * as changeActiveTextEditor from './events/change_active_text_editor'
+import * as changeActiveTextEditor from './events/change_active_text_editor';
 import * as changeTextDocument from './events/change_text_document';
 
 export {
     changeActiveTextEditor,
-    changeTextDocument
+    changeTextDocument,
-}
+};

editors/code/src/events/change_active_text_editor.ts

@@ -1,14 +1,14 @@
-import { TextEditor } from "vscode";
+import { TextEditor } from 'vscode';
-import { TextDocumentIdentifier } from "vscode-languageclient";
+import { TextDocumentIdentifier } from 'vscode-languageclient';
 
-import { Server } from "../server";
+import { Decoration } from '../highlighting';
-import { Decoration } from "../highlighting";
+import { Server } from '../server';
 
 export async function handle(editor: TextEditor | undefined) {
-    if (!Server.config.highlightingOn || !editor || editor.document.languageId != 'rust') return
+    if (!Server.config.highlightingOn || !editor || editor.document.languageId != 'rust') { return; }
-    let params: TextDocumentIdentifier = {
+    const params: TextDocumentIdentifier = {
-        uri: editor.document.uri.toString()
+        uri: editor.document.uri.toString(),
-    }
+    };
-    let decorations = await Server.client.sendRequest<Decoration[]>("m/decorationsRequest", params)
+    const decorations = await Server.client.sendRequest<Decoration[]>('m/decorationsRequest', params);
-    Server.highlighter.setHighlights(editor, decorations)
+    Server.highlighter.setHighlights(editor, decorations);
-}
+}

editors/code/src/events/change_text_document.ts

@@ -4,16 +4,16 @@ import { syntaxTreeUri, TextDocumentContentProvider } from '../commands/syntaxTr
 
 export function createHandler(textDocumentContentProvider: TextDocumentContentProvider) {
     return (event: vscode.TextDocumentChangeEvent) => {
-        let doc = event.document
+        const doc = event.document;
-        if (doc.languageId != "rust") return
+        if (doc.languageId != 'rust') { return; }
         afterLs(() => {
             textDocumentContentProvider.eventEmitter.fire(syntaxTreeUri);
-        })
+        });
-    }
+    };
 }
 
 // We need to order this after LS updates, but there's no API for that.
 // Hence, good old setTimeout.
 function afterLs(f: () => any) {
-    setTimeout(f, 10)
+    setTimeout(f, 10);
 }

editors/code/src/extension.ts

@@ -1,9 +1,9 @@
 import * as vscode from 'vscode';
 
-import * as commands from './commands'
+import * as commands from './commands';
-import * as events from './events'
-import { Server } from './server';
 import { TextDocumentContentProvider } from './commands/syntaxTree';
+import * as events from './events';
+import { Server } from './server';
 
 export function activate(context: vscode.ExtensionContext) {
     function disposeOnDeactivation(disposable: vscode.Disposable) {
@@ -11,10 +11,10 @@ export function activate(context: vscode.ExtensionContext) {
     }
 
     function registerCommand(name: string, f: any) {
-        disposeOnDeactivation(vscode.commands.registerCommand(name, f))
+        disposeOnDeactivation(vscode.commands.registerCommand(name, f));
     }
 
-    registerCommand('ra-lsp.syntaxTree', commands.syntaxTree.handle)
+    registerCommand('ra-lsp.syntaxTree', commands.syntaxTree.handle);
     registerCommand('ra-lsp.extendSelection', commands.extendSelection.handle);
     registerCommand('ra-lsp.matchingBrace', commands.matchingBrace.handle);
     registerCommand('ra-lsp.joinLines', commands.joinLines.handle);
@@ -22,19 +22,19 @@ export function activate(context: vscode.ExtensionContext) {
     registerCommand('ra-lsp.run', commands.runnables.handle);
     registerCommand('ra-lsp.applySourceChange', commands.applySourceChange.handle);
 
-    let textDocumentContentProvider = new TextDocumentContentProvider()
+    const textDocumentContentProvider = new TextDocumentContentProvider();
     disposeOnDeactivation(vscode.workspace.registerTextDocumentContentProvider(
         'ra-lsp',
-        textDocumentContentProvider
+        textDocumentContentProvider,
-    ))
+    ));
 
-    Server.start()
+    Server.start();
 
     vscode.workspace.onDidChangeTextDocument(
         events.changeTextDocument.createHandler(textDocumentContentProvider),
         null,
-        context.subscriptions)
+        context.subscriptions);
-    vscode.window.onDidChangeActiveTextEditor(events.changeActiveTextEditor.handle)
+    vscode.window.onDidChangeActiveTextEditor(events.changeActiveTextEditor.handle);
 }
 
 export function deactivate(): Thenable<void> {

editors/code/src/highlighting.ts

@@ -1,11 +1,11 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient'
+import * as lc from 'vscode-languageclient';
 
 import { Server } from './server';
 
 export interface Decoration {
-    range: lc.Range,
+    range: lc.Range;
-    tag: string,
+    tag: string;
 }
 
 export class Highlighter {
@@ -14,17 +14,17 @@ export class Highlighter {
         this.decorations = {};
     }
 
-    removeHighlights() {
+    public removeHighlights() {
-        for (let tag in this.decorations) {
+        for (const tag in this.decorations) {
             this.decorations[tag].dispose();
         }
 
         this.decorations = {};
     }
 
-    setHighlights(
+    public setHighlights(
         editor: vscode.TextEditor,
-        highlights: Array<Decoration>
+        highlights: Decoration[],
     ) {
         // Initialize decorations if necessary
         //
@@ -34,45 +34,45 @@ export class Highlighter {
             this.initDecorations();
         }
 
-        let byTag: Map<string, vscode.Range[]> = new Map()
+        const byTag: Map<string, vscode.Range[]> = new Map();
-        for (let tag in this.decorations) {
+        for (const tag in this.decorations) {
-            byTag.set(tag, [])
+            byTag.set(tag, []);
         }
 
-        for (let d of highlights) {
+        for (const d of highlights) {
             if (!byTag.get(d.tag)) {
-                console.log(`unknown tag ${d.tag}`)
+                console.log(`unknown tag ${d.tag}`);
-                continue
+                continue;
             }
             byTag.get(d.tag)!.push(
-                Server.client.protocol2CodeConverter.asRange(d.range)
+                Server.client.protocol2CodeConverter.asRange(d.range),
-            )
+            );
         }
 
-        for (let tag of byTag.keys()) {
+        for (const tag of byTag.keys()) {
-            let dec: vscode.TextEditorDecorationType = this.decorations[tag]
+            const dec: vscode.TextEditorDecorationType = this.decorations[tag];
-            let ranges = byTag.get(tag)!
+            const ranges = byTag.get(tag)!;
-            editor.setDecorations(dec, ranges)
+            editor.setDecorations(dec, ranges);
         }
     }
 
     private initDecorations() {
-        const decor = (obj: any) => vscode.window.createTextEditorDecorationType({ color: obj })
+        const decor = (obj: any) => vscode.window.createTextEditorDecorationType({ color: obj });
         this.decorations = {
-            background: decor("#3F3F3F"),
+            background: decor('#3F3F3F'),
             error: vscode.window.createTextEditorDecorationType({
-                borderColor: "red",
+                borderColor: 'red',
-                borderStyle: "none none dashed none",
+                borderStyle: 'none none dashed none',
             }),
-            comment: decor("#7F9F7F"),
+            comment: decor('#7F9F7F'),
-            string: decor("#CC9393"),
+            string: decor('#CC9393'),
-            keyword: decor("#F0DFAF"),
+            keyword: decor('#F0DFAF'),
-            function: decor("#93E0E3"),
+            function: decor('#93E0E3'),
-            parameter: decor("#94BFF3"),
+            parameter: decor('#94BFF3'),
-            builtin: decor("#DD6718"),
+            builtin: decor('#DD6718'),
-            text: decor("#DCDCCC"),
+            text: decor('#DCDCCC'),
-            attribute: decor("#BFEBBF"),
+            attribute: decor('#BFEBBF'),
-            literal: decor("#DFAF8F"),
+            literal: decor('#DFAF8F'),
-        }
+        };
     }
 }

editors/code/src/server.ts

@@ -1,45 +1,25 @@
 import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient'
+import * as lc from 'vscode-languageclient';
 
-import { Highlighter, Decoration } from './highlighting';
+import { Config } from './config';
-
+import { Decoration, Highlighter } from './highlighting';
-export class Config {
-    highlightingOn = true;
-
-    constructor() {
-        vscode.workspace.onDidChangeConfiguration(_ => this.userConfigChanged());
-        this.userConfigChanged();
-    }
-
-    userConfigChanged() {
-        let config = vscode.workspace.getConfiguration('ra-lsp');
-        if (config.has('highlightingOn')) {
-            this.highlightingOn = config.get('highlightingOn') as boolean;
-        };
-
-        if (!this.highlightingOn) {
-            Server.highlighter.removeHighlights();
-        }
-    }
-}
 
 export class Server {
-    static highlighter = new Highlighter();
+    public static highlighter = new Highlighter();
-    static config = new Config();
+    public static config = new Config();
-    static client: lc.LanguageClient;
+    public static client: lc.LanguageClient;
 
-
+    public static start() {
-    static start() {
+        const run: lc.Executable = {
-        let run: lc.Executable = {
+            command: 'ra_lsp_server',
-            command: "ra_lsp_server",
+            options: { cwd: '.' },
-            options: { cwd: "." }
+        };
-        }
+        const serverOptions: lc.ServerOptions = {
-        let serverOptions: lc.ServerOptions = {
             run,
-            debug: run
+            debug: run,
         };
 
-        let clientOptions: lc.LanguageClientOptions = {
+        const clientOptions: lc.LanguageClientOptions = {
             documentSelector: [{ scheme: 'file', language: 'rust' }],
         };
 
@@ -51,24 +31,24 @@ export class Server {
         );
         Server.client.onReady().then(() => {
             Server.client.onNotification(
-                "m/publishDecorations",
+                'm/publishDecorations',
                 (params: PublishDecorationsParams) => {
-                    let editor = vscode.window.visibleTextEditors.find(
+                    const targetEditor = vscode.window.visibleTextEditors.find(
-                        (editor) => editor.document.uri.toString() == params.uri
+                        (editor) => editor.document.uri.toString() == params.uri,
-                    )
+                    );
-                    if (!Server.config.highlightingOn || !editor) return;
+                    if (!Server.config.highlightingOn || !targetEditor) { return; }
                     Server.highlighter.setHighlights(
-                        editor,
+                        targetEditor,
                         params.decorations,
-                    )
+                    );
-                }
+                },
-            )
+            );
-        })
+        });
         Server.client.start();
     }
 }
 
 interface PublishDecorationsParams {
-    uri: string,
+    uri: string;
-    decorations: Decoration[],
+    decorations: Decoration[];
 }

editors/code/tslint.json

@@ -0,0 +1,13 @@
+{
+    "defaultSeverity": "warning",
+    "extends": [
+        "tslint:recommended"
+    ],
+    "jsRules": {},
+    "rules": {
+        "quotemark": [true, "single"],
+        "interface-name": false,
+        "object-literal-sort-keys": false
+    },
+    "rulesDirectory": []
+}