vscode-eslint 0.0.1

package/server/src/is.ts

@@ -0,0 +1,18 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+const toString = Object.prototype.toString;
+
+export function boolean(value: any): value is boolean {
+	return value === true || value === false;
+}
+
+export function nullOrUndefined(value: any): value is null | undefined {
+	return value === null || value === undefined;
+}
+
+export function string(value: any): value is string {
+	return toString.call(value) === '[object String]';
+}

package/server/src/languageDefaults.ts

@@ -0,0 +1,40 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+// This should either come from LSP or VS Code. That we repeat this is bogus.
+
+type LanguageConfig = {
+	ext: string;
+	lineComment: string;
+	blockComment: [string, string];
+};
+
+const languageId2Config: Map<string, LanguageConfig> = new Map([
+	['javascript', { ext: 'js', lineComment: '//', blockComment: ['/*', '*/'] }],
+	['javascriptreact', { ext: 'jsx', lineComment: '//', blockComment: ['/*', '*/'] }],
+	['typescript', { ext: 'ts', lineComment: '//', blockComment: ['/*', '*/'] } ],
+	['typescriptreact', { ext: 'tsx', lineComment: '//', blockComment: ['/*', '*/'] } ],
+	['html', { ext: 'html', lineComment: '//', blockComment: ['<!--', '-->'] }],
+	['vue', { ext: 'vue', lineComment: '//', blockComment: ['<!--', '-->'] }],
+	['coffeescript', { ext: 'coffee', lineComment: '#', blockComment: ['###', '###'] }],
+	['yaml', { ext: 'yaml', lineComment: '#', blockComment: ['#', ''] }],
+	['graphql', { ext: 'graphql', lineComment: '#', blockComment: ['#', ''] }]
+]);
+
+namespace LanguageDefaults {
+	export function getLineComment(languageId: string): string {
+		return languageId2Config.get(languageId)?.lineComment ?? '//';
+	}
+
+	export function getBlockComment(languageId: string): [string, string] {
+		return languageId2Config.get(languageId)?.blockComment ?? ['/*', '*/'];
+	}
+
+	export function getExtension(languageId: string): string | undefined {
+		return languageId2Config.get(languageId)?.ext;
+	}
+}
+
+export default LanguageDefaults;

package/server/src/linkedMap.ts

@@ -0,0 +1,448 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+interface Item<K, V> {
+	previous: Item<K, V> | undefined;
+	next: Item<K, V> | undefined;
+	key: K;
+	value: V;
+}
+
+export namespace Touch {
+	export const None: 0 = 0;
+	export const First: 1 = 1;
+	export const AsOld: 1 = Touch.First;
+	export const Last: 2 = 2;
+	export const AsNew: 2 = Touch.Last;
+}
+
+export type Touch = 0 | 1 | 2;
+
+export class LinkedMap<K, V> implements Map<K, V> {
+
+	readonly [Symbol.toStringTag] = 'LinkedMap';
+
+	private _map: Map<K, Item<K, V>>;
+	private _head: Item<K, V> | undefined;
+	private _tail: Item<K, V> | undefined;
+	private _size: number;
+
+	private _state: number;
+
+	public constructor() {
+		this._map = new Map<K, Item<K, V>>();
+		this._head = undefined;
+		this._tail = undefined;
+		this._size = 0;
+		this._state = 0;
+	}
+
+	public clear(): void {
+		this._map.clear();
+		this._head = undefined;
+		this._tail = undefined;
+		this._size = 0;
+		this._state++;
+	}
+
+	public isEmpty(): boolean {
+		return !this._head && !this._tail;
+	}
+
+	public get size(): number {
+		return this._size;
+	}
+
+	public get first(): V | undefined {
+		return this._head?.value;
+	}
+
+	public get last(): V | undefined {
+		return this._tail?.value;
+	}
+
+	public has(key: K): boolean {
+		return this._map.has(key);
+	}
+
+	public get(key: K, touch: Touch = Touch.None): V | undefined {
+		const item = this._map.get(key);
+		if (!item) {
+			return undefined;
+		}
+		if (touch !== Touch.None) {
+			this.touch(item, touch);
+		}
+		return item.value;
+	}
+
+	public set(key: K, value: V, touch: Touch = Touch.None): this {
+		let item = this._map.get(key);
+		if (item) {
+			item.value = value;
+			if (touch !== Touch.None) {
+				this.touch(item, touch);
+			}
+		} else {
+			item = { key, value, next: undefined, previous: undefined };
+			switch (touch) {
+				case Touch.None:
+					this.addItemLast(item);
+					break;
+				case Touch.First:
+					this.addItemFirst(item);
+					break;
+				case Touch.Last:
+					this.addItemLast(item);
+					break;
+				default:
+					this.addItemLast(item);
+					break;
+			}
+			this._map.set(key, item);
+			this._size++;
+		}
+		return this;
+	}
+
+	public delete(key: K): boolean {
+		return !!this.remove(key);
+	}
+
+	public remove(key: K): V | undefined {
+		const item = this._map.get(key);
+		if (!item) {
+			return undefined;
+		}
+		this._map.delete(key);
+		this.removeItem(item);
+		this._size--;
+		return item.value;
+	}
+
+	public shift(): V | undefined {
+		if (!this._head && !this._tail) {
+			return undefined;
+		}
+		if (!this._head || !this._tail) {
+			throw new Error('Invalid list');
+		}
+		const item = this._head;
+		this._map.delete(item.key);
+		this.removeItem(item);
+		this._size--;
+		return item.value;
+	}
+
+	public forEach(callbackfn: (value: V, key: K, map: LinkedMap<K, V>) => void, thisArg?: any): void {
+		const state = this._state;
+		let current = this._head;
+		while (current) {
+			if (thisArg) {
+				callbackfn.bind(thisArg)(current.value, current.key, this);
+			} else {
+				callbackfn(current.value, current.key, this);
+			}
+			if (this._state !== state) {
+				throw new Error(`LinkedMap got modified during iteration.`);
+			}
+			current = current.next;
+		}
+	}
+
+	public keys(): IterableIterator<K> {
+		const map = this;
+		const state = this._state;
+		let current = this._head;
+		const iterator: IterableIterator<K> = {
+			[Symbol.iterator]() {
+				return iterator;
+			},
+			next(): IteratorResult<K> {
+				if (map._state !== state) {
+					throw new Error(`LinkedMap got modified during iteration.`);
+				}
+				if (current) {
+					const result = { value: current.key, done: false };
+					current = current.next;
+					return result;
+				} else {
+					return { value: undefined, done: true };
+				}
+			}
+		};
+		return iterator;
+	}
+
+	public values(): IterableIterator<V> {
+		const map = this;
+		const state = this._state;
+		let current = this._head;
+		const iterator: IterableIterator<V> = {
+			[Symbol.iterator]() {
+				return iterator;
+			},
+			next(): IteratorResult<V> {
+				if (map._state !== state) {
+					throw new Error(`LinkedMap got modified during iteration.`);
+				}
+				if (current) {
+					const result = { value: current.value, done: false };
+					current = current.next;
+					return result;
+				} else {
+					return { value: undefined, done: true };
+				}
+			}
+		};
+		return iterator;
+	}
+
+	public entries(): IterableIterator<[K, V]> {
+		const map = this;
+		const state = this._state;
+		let current = this._head;
+		const iterator: IterableIterator<[K, V]> = {
+			[Symbol.iterator]() {
+				return iterator;
+			},
+			next(): IteratorResult<[K, V]> {
+				if (map._state !== state) {
+					throw new Error(`LinkedMap got modified during iteration.`);
+				}
+				if (current) {
+					const result: IteratorResult<[K, V]> = { value: [current.key, current.value], done: false };
+					current = current.next;
+					return result;
+				} else {
+					return { value: undefined, done: true };
+				}
+			}
+		};
+		return iterator;
+	}
+
+	public [Symbol.iterator](): IterableIterator<[K, V]> {
+		return this.entries();
+	}
+
+	protected trimOld(newSize: number) {
+		if (newSize >= this.size) {
+			return;
+		}
+		if (newSize === 0) {
+			this.clear();
+			return;
+		}
+		let current = this._head;
+		let currentSize = this.size;
+		while (current && currentSize > newSize) {
+			this._map.delete(current.key);
+			current = current.next;
+			currentSize--;
+		}
+		this._head = current;
+		this._size = currentSize;
+		if (current) {
+			current.previous = undefined;
+		}
+		this._state++;
+	}
+
+	private addItemFirst(item: Item<K, V>): void {
+		// First time Insert
+		if (!this._head && !this._tail) {
+			this._tail = item;
+		} else if (!this._head) {
+			throw new Error('Invalid list');
+		} else {
+			item.next = this._head;
+			this._head.previous = item;
+		}
+		this._head = item;
+		this._state++;
+	}
+
+	private addItemLast(item: Item<K, V>): void {
+		// First time Insert
+		if (!this._head && !this._tail) {
+			this._head = item;
+		} else if (!this._tail) {
+			throw new Error('Invalid list');
+		} else {
+			item.previous = this._tail;
+			this._tail.next = item;
+		}
+		this._tail = item;
+		this._state++;
+	}
+
+	private removeItem(item: Item<K, V>): void {
+		if (item === this._head && item === this._tail) {
+			this._head = undefined;
+			this._tail = undefined;
+		}
+		else if (item === this._head) {
+			// This can only happen if size === 1 which is handled
+			// by the case above.
+			if (!item.next) {
+				throw new Error('Invalid list');
+			}
+			item.next.previous = undefined;
+			this._head = item.next;
+		}
+		else if (item === this._tail) {
+			// This can only happen if size === 1 which is handled
+			// by the case above.
+			if (!item.previous) {
+				throw new Error('Invalid list');
+			}
+			item.previous.next = undefined;
+			this._tail = item.previous;
+		}
+		else {
+			const next = item.next;
+			const previous = item.previous;
+			if (!next || !previous) {
+				throw new Error('Invalid list');
+			}
+			next.previous = previous;
+			previous.next = next;
+		}
+		item.next = undefined;
+		item.previous = undefined;
+		this._state++;
+	}
+
+	private touch(item: Item<K, V>, touch: Touch): void {
+		if (!this._head || !this._tail) {
+			throw new Error('Invalid list');
+		}
+		if ((touch !== Touch.First && touch !== Touch.Last)) {
+			return;
+		}
+
+		if (touch === Touch.First) {
+			if (item === this._head) {
+				return;
+			}
+
+			const next = item.next;
+			const previous = item.previous;
+
+			// Unlink the item
+			if (item === this._tail) {
+				// previous must be defined since item was not head but is tail
+				// So there are more than on item in the map
+				previous!.next = undefined;
+				this._tail = previous;
+			}
+			else {
+				// Both next and previous are not undefined since item was neither head nor tail.
+				next!.previous = previous;
+				previous!.next = next;
+			}
+
+			// Insert the node at head
+			item.previous = undefined;
+			item.next = this._head;
+			this._head.previous = item;
+			this._head = item;
+			this._state++;
+		} else if (touch === Touch.Last) {
+			if (item === this._tail) {
+				return;
+			}
+
+			const next = item.next;
+			const previous = item.previous;
+
+			// Unlink the item.
+			if (item === this._head) {
+				// next must be defined since item was not tail but is head
+				// So there are more than on item in the map
+				next!.previous = undefined;
+				this._head = next;
+			} else {
+				// Both next and previous are not undefined since item was neither head nor tail.
+				next!.previous = previous;
+				previous!.next = next;
+			}
+			item.next = undefined;
+			item.previous = this._tail;
+			this._tail.next = item;
+			this._tail = item;
+			this._state++;
+		}
+	}
+
+	public toJSON(): [K, V][] {
+		const data: [K, V][] = [];
+
+		this.forEach((value, key) => {
+			data.push([key, value]);
+		});
+
+		return data;
+	}
+
+	public fromJSON(data: [K, V][]): void {
+		this.clear();
+
+		for (const [key, value] of data) {
+			this.set(key, value);
+		}
+	}
+}
+
+export class LRUCache<K, V> extends LinkedMap<K, V> {
+
+	private _limit: number;
+	private _ratio: number;
+
+	public constructor(limit: number, ratio: number = 1) {
+		super();
+		this._limit = limit;
+		this._ratio = Math.min(Math.max(0, ratio), 1);
+	}
+
+	public get limit(): number {
+		return this._limit;
+	}
+
+	public set limit(limit: number) {
+		this._limit = limit;
+		this.checkTrim();
+	}
+
+	public get ratio(): number {
+		return this._ratio;
+	}
+
+	public set ratio(ratio: number) {
+		this._ratio = Math.min(Math.max(0, ratio), 1);
+		this.checkTrim();
+	}
+
+	public get(key: K, touch: Touch = Touch.AsNew): V | undefined {
+		return super.get(key, touch);
+	}
+
+	public peek(key: K): V | undefined {
+		return super.get(key, Touch.None);
+	}
+
+	public set(key: K, value: V): this {
+		super.set(key, value, Touch.Last);
+		this.checkTrim();
+		return this;
+	}
+
+	private checkTrim() {
+		if (this.size > this._limit) {
+			this.trimOld(Math.round(this._limit * this._ratio));
+		}
+	}
+}

package/server/src/paths.ts

@@ -0,0 +1,128 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import * as fs from 'fs';
+
+import { URI } from 'vscode-uri';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+
+import * as Is from './is';
+
+/**
+ * Special functions to deal with path conversions in the context of ESLint
+ */
+
+/**
+ * Normalizes the drive letter to upper case which is the default in Node but not in
+ * VS Code.
+ */
+export function normalizeDriveLetter(path: string): string {
+	if (process.platform !== 'win32' || path.length < 2 || path[1] !== ':') {
+		return path;
+	}
+	return path[0].toUpperCase() + path.substring(1);
+}
+
+const enum CharCode {
+	/**
+	 * The `\` character.
+	 */
+	Backslash = 92,
+}
+
+/**
+ * Check if the path follows this pattern: `\\hostname\sharename`.
+ *
+ * @see https://msdn.microsoft.com/en-us/library/gg465305.aspx
+ * @return A boolean indication if the path is a UNC path, on none-windows
+ * always false.
+ */
+export function isUNC(path: string): boolean {
+	if (process.platform !== 'win32') {
+		// UNC is a windows concept
+		return false;
+	}
+
+	if (!path || path.length < 5) {
+		// at least \\a\b
+		return false;
+	}
+
+	let code = path.charCodeAt(0);
+	if (code !== CharCode.Backslash) {
+		return false;
+	}
+	code = path.charCodeAt(1);
+	if (code !== CharCode.Backslash) {
+		return false;
+	}
+	let pos = 2;
+	const start = pos;
+	for (; pos < path.length; pos++) {
+		code = path.charCodeAt(pos);
+		if (code === CharCode.Backslash) {
+			break;
+		}
+	}
+	if (start === pos) {
+		return false;
+	}
+	code = path.charCodeAt(pos + 1);
+	if (isNaN(code) || code === CharCode.Backslash) {
+		return false;
+	}
+	return true;
+}
+
+export function getFileSystemPath(uri: URI, useRealpaths: boolean): string {
+	let result = uri.fsPath;
+	if (process.platform === 'win32' && result.length >= 2 && result[1] === ':') {
+		// Node by default uses an upper case drive letter and ESLint uses
+		// === to compare paths which results in the equal check failing
+		// if the drive letter is lower case in th URI. Ensure upper case.
+		result = result[0].toUpperCase() + result.substr(1);
+	}
+	if (useRealpaths) {
+		result = tryRealpath(result);
+	} else if (process.platform === 'win32' || process.platform === 'darwin') {
+		const realpath = tryRealpath(result);
+		// Only use the real path if only the casing has changed.
+		if (realpath.toLowerCase() === result.toLowerCase()) {
+			result = realpath;
+		}
+	}
+	return result;
+}
+
+function tryRealpath(path: string): string {
+	try {
+		return fs.realpathSync.native(path);
+	} catch (error) {
+		// Silently ignore errors from `fs.realpathSync` to handle scenarios where
+		// the file being linted is not yet written to disk. This occurs in editors
+		// such as Neovim for non-written buffers.
+		return path;
+	}
+}
+
+export function normalizePath(path: string): string;
+export function normalizePath(path: undefined): undefined;
+export function normalizePath(path: string | undefined): string | undefined {
+	if (path === undefined) {
+		return undefined;
+	}
+	if (process.platform === 'win32') {
+		return path.replace(/\\/g, '/');
+	}
+	return path;
+}
+
+export function getUri(documentOrUri: string | TextDocument | URI): URI {
+	return Is.string(documentOrUri)
+		? URI.parse(documentOrUri)
+		: documentOrUri instanceof URI
+			? documentOrUri
+			: URI.parse(documentOrUri.uri);
+}

package/server/src/thenable.d.ts

@@ -0,0 +1,5 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+interface Thenable<T> extends PromiseLike<T> {}

package/server/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"extends": "../tsconfig.base.json",
+	"compilerOptions": {
+		"module": "Node16",
+		"moduleResolution": "Node16",
+		"target": "ES2022",
+		"sourceMap": true,
+		"outDir": "out",
+		"rootDir": "src",
+		"lib": [ "ES2023" ],
+		"tsBuildInfoFile": "out/compile.tsbuildinfo",
+        "incremental": true,
+        "composite": true
+	},
+	"include": [
+		"src"
+	],
+	"exclude": [
+		"node_modules"
+	]
+}

package/server/webpack.config.js

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+//@ts-check
+
+'use strict';
+
+const withDefaults = require('../shared.webpack.config');
+const path = require('path');
+
+module.exports = withDefaults({
+	context: path.join(__dirname),
+	entry: {
+		extension: './src/eslintServer.ts',
+	},
+	resolve: {
+		symlinks: false
+	},
+	output: {
+		filename: 'eslintServer.js',
+		path: path.join(__dirname, 'out')
+	}
+});