matchingBrace,
parentModule,
runnables,
- syntaxTree
-}
+ syntaxTree,
+};
import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient'
+import * as lc from 'vscode-languageclient';
import { Server } from '../server';
}
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);
}
}
import * as vscode from 'vscode';
-import { TextDocumentIdentifier, Range } from "vscode-languageclient";
+import { Range, TextDocumentIdentifier } from 'vscode-languageclient';
import { Server } from '../server';
interface ExtendSelectionParams {
}
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);
+ });
}
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';
}
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);
}
import * as vscode from 'vscode';
-import { TextDocumentIdentifier, Position } from "vscode-languageclient";
+import { Position, TextDocumentIdentifier } from 'vscode-languageclient';
import { Server } from '../server';
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);
+}
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);
}
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 {
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;
}
}
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);
}
}
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;
}
}
//
// 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);
}
--- /dev/null
+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();
+ }
+ }
+}
-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
-}
\ No newline at end of file
+ changeTextDocument,
+};
-import { TextEditor } from "vscode";
-import { TextDocumentIdentifier } from "vscode-languageclient";
+import { TextEditor } from 'vscode';
+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
- let params: TextDocumentIdentifier = {
- uri: editor.document.uri.toString()
- }
- let decorations = await Server.client.sendRequest<Decoration[]>("m/decorationsRequest", params)
- Server.highlighter.setHighlights(editor, decorations)
-}
\ No newline at end of file
+ if (!Server.config.highlightingOn || !editor || editor.document.languageId != 'rust') { return; }
+ const params: TextDocumentIdentifier = {
+ uri: editor.document.uri.toString(),
+ };
+ const decorations = await Server.client.sendRequest<Decoration[]>('m/decorationsRequest', params);
+ Server.highlighter.setHighlights(editor, decorations);
+}
export function createHandler(textDocumentContentProvider: TextDocumentContentProvider) {
return (event: vscode.TextDocumentChangeEvent) => {
- let doc = event.document
- if (doc.languageId != "rust") return
+ const doc = event.document;
+ 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);
}
import * as vscode from 'vscode';
-import * as commands from './commands'
-import * as events from './events'
-import { Server } from './server';
+import * as commands from './commands';
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) {
}
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);
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)
- vscode.window.onDidChangeActiveTextEditor(events.changeActiveTextEditor.handle)
+ context.subscriptions);
+ vscode.window.onDidChangeActiveTextEditor(events.changeActiveTextEditor.handle);
}
export function deactivate(): Thenable<void> {
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,
- tag: string,
+ range: lc.Range;
+ tag: string;
}
export class Highlighter {
this.decorations = {};
}
- removeHighlights() {
- for (let tag in this.decorations) {
+ public removeHighlights() {
+ 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
//
this.initDecorations();
}
- let byTag: Map<string, vscode.Range[]> = new Map()
- for (let tag in this.decorations) {
- byTag.set(tag, [])
+ const byTag: Map<string, vscode.Range[]> = new Map();
+ for (const tag in this.decorations) {
+ byTag.set(tag, []);
}
- for (let d of highlights) {
+ for (const d of highlights) {
if (!byTag.get(d.tag)) {
- console.log(`unknown tag ${d.tag}`)
- continue
+ console.log(`unknown tag ${d.tag}`);
+ continue;
}
byTag.get(d.tag)!.push(
- Server.client.protocol2CodeConverter.asRange(d.range)
- )
+ Server.client.protocol2CodeConverter.asRange(d.range),
+ );
}
- for (let tag of byTag.keys()) {
- let dec: vscode.TextEditorDecorationType = this.decorations[tag]
- let ranges = byTag.get(tag)!
- editor.setDecorations(dec, ranges)
+ for (const tag of byTag.keys()) {
+ const dec: vscode.TextEditorDecorationType = this.decorations[tag];
+ const ranges = byTag.get(tag)!;
+ 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",
- borderStyle: "none none dashed none",
+ borderColor: 'red',
+ borderStyle: 'none none dashed none',
}),
- comment: decor("#7F9F7F"),
- string: decor("#CC9393"),
- keyword: decor("#F0DFAF"),
- function: decor("#93E0E3"),
- parameter: decor("#94BFF3"),
- builtin: decor("#DD6718"),
- text: decor("#DCDCCC"),
- attribute: decor("#BFEBBF"),
- literal: decor("#DFAF8F"),
- }
+ comment: decor('#7F9F7F'),
+ string: decor('#CC9393'),
+ keyword: decor('#F0DFAF'),
+ function: decor('#93E0E3'),
+ parameter: decor('#94BFF3'),
+ builtin: decor('#DD6718'),
+ text: decor('#DCDCCC'),
+ attribute: decor('#BFEBBF'),
+ literal: decor('#DFAF8F'),
+ };
}
}
import * as vscode from 'vscode';
-import * as lc from 'vscode-languageclient'
+import * as lc from 'vscode-languageclient';
-import { Highlighter, Decoration } 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();
- }
- }
-}
+import { Config } from './config';
+import { Decoration, Highlighter } from './highlighting';
export class Server {
- static highlighter = new Highlighter();
- static config = new Config();
- static client: lc.LanguageClient;
-
-
- static start() {
- let run: lc.Executable = {
- command: "ra_lsp_server",
- options: { cwd: "." }
- }
- let serverOptions: lc.ServerOptions = {
+ public static highlighter = new Highlighter();
+ public static config = new Config();
+ public static client: lc.LanguageClient;
+
+ public static start() {
+ const run: lc.Executable = {
+ command: 'ra_lsp_server',
+ options: { cwd: '.' },
+ };
+ const serverOptions: lc.ServerOptions = {
run,
- debug: run
+ debug: run,
};
- let clientOptions: lc.LanguageClientOptions = {
+ const clientOptions: lc.LanguageClientOptions = {
documentSelector: [{ scheme: 'file', language: 'rust' }],
};
);
Server.client.onReady().then(() => {
Server.client.onNotification(
- "m/publishDecorations",
+ 'm/publishDecorations',
(params: PublishDecorationsParams) => {
- let editor = vscode.window.visibleTextEditors.find(
- (editor) => editor.document.uri.toString() == params.uri
- )
- if (!Server.config.highlightingOn || !editor) return;
+ const targetEditor = vscode.window.visibleTextEditors.find(
+ (editor) => editor.document.uri.toString() == params.uri,
+ );
+ if (!Server.config.highlightingOn || !targetEditor) { return; }
Server.highlighter.setHighlights(
- editor,
+ targetEditor,
params.decorations,
- )
- }
- )
- })
+ );
+ },
+ );
+ });
Server.client.start();
}
}
interface PublishDecorationsParams {
- uri: string,
- decorations: Decoration[],
+ uri: string;
+ decorations: Decoration[];
}
--- /dev/null
+{
+ "defaultSeverity": "warning",
+ "extends": [
+ "tslint:recommended"
+ ],
+ "jsRules": {},
+ "rules": {
+ "quotemark": [true, "single"],
+ "interface-name": false,
+ "object-literal-sort-keys": false
+ },
+ "rulesDirectory": []
+}
projects / rust.git / commitdiff