[json] split json extension (for #45900)

extensions/json-language-features/server/src/jsonFolding.ts

@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { TextDocument, Position, CancellationToken } from 'vscode-languageserver';
+import { createScanner, SyntaxKind, ScanError } from 'jsonc-parser';
+import { FoldingRangeType, FoldingRange, FoldingRangeList } from './protocol/foldingProvider.proposed';
+
+export function getFoldingRegions(document: TextDocument, maxRanges: number | undefined, cancellationToken: CancellationToken | null) {
+	let ranges: FoldingRange[] = [];
+	let nestingLevels: number[] = [];
+	let stack: FoldingRange[] = [];
+	let prevStart = -1;
+	let scanner = createScanner(document.getText(), false);
+	let token = scanner.scan();
+
+	function addRange(range: FoldingRange) {
+		ranges.push(range);
+		nestingLevels.push(stack.length);
+	}
+
+	while (token !== SyntaxKind.EOF) {
+		if (cancellationToken && cancellationToken.isCancellationRequested) {
+			return null;
+		}
+		switch (token) {
+			case SyntaxKind.OpenBraceToken:
+			case SyntaxKind.OpenBracketToken: {
+				let startLine = document.positionAt(scanner.getTokenOffset()).line;
+				let range = { startLine, endLine: startLine, type: token === SyntaxKind.OpenBraceToken ? 'object' : 'array' };
+				stack.push(range);
+				break;
+			}
+			case SyntaxKind.CloseBraceToken:
+			case SyntaxKind.CloseBracketToken: {
+				let type = token === SyntaxKind.CloseBraceToken ? 'object' : 'array';
+				if (stack.length > 0 && stack[stack.length - 1].type === type) {
+					let range = stack.pop();
+					let line = document.positionAt(scanner.getTokenOffset()).line;
+					if (range && line > range.startLine + 1 && prevStart !== range.startLine) {
+						range.endLine = line - 1;
+						addRange(range);
+						prevStart = range.startLine;
+					}
+				}
+				break;
+			}
+
+			case SyntaxKind.BlockCommentTrivia: {
+				let startLine = document.positionAt(scanner.getTokenOffset()).line;
+				let endLine = document.positionAt(scanner.getTokenOffset() + scanner.getTokenLength()).line;
+				if (scanner.getTokenError() === ScanError.UnexpectedEndOfComment && startLine + 1 < document.lineCount) {
+					scanner.setPosition(document.offsetAt(Position.create(startLine + 1, 0)));
+				} else {
+					if (startLine < endLine) {
+						addRange({ startLine, endLine, type: FoldingRangeType.Comment });
+						prevStart = startLine;
+					}
+				}
+				break;
+			}
+
+			case SyntaxKind.LineCommentTrivia: {
+				let text = document.getText().substr(scanner.getTokenOffset(), scanner.getTokenLength());
+				let m = text.match(/^\/\/\s*#(region\b)|(endregion\b)/);
+				if (m) {
+					let line = document.positionAt(scanner.getTokenOffset()).line;
+					if (m[1]) { // start pattern match
+						let range = { startLine: line, endLine: line, type: FoldingRangeType.Region };
+						stack.push(range);
+					} else {
+						let i = stack.length - 1;
+						while (i >= 0 && stack[i].type !== FoldingRangeType.Region) {
+							i--;
+						}
+						if (i >= 0) {
+							let range = stack[i];
+							stack.length = i;
+							if (line > range.startLine && prevStart !== range.startLine) {
+								range.endLine = line;
+								addRange(range);
+								prevStart = range.startLine;
+							}
+						}
+					}
+				}
+				break;
+			}
+
+		}
+		token = scanner.scan();
+	}
+	if (maxRanges && ranges.length > maxRanges) {
+		let counts: number[] = [];
+		for (let level of nestingLevels) {
+			if (level < 30) {
+				counts[level] = (counts[level] || 0) + 1;
+			}
+		}
+		let entries = 0;
+		let maxLevel = 0;
+		for (let i = 0; i < counts.length; i++) {
+			let n = counts[i];
+			if (n) {
+				if (n + entries > maxRanges) {
+					maxLevel = i;
+					break;
+				}
+				entries += n;
+			}
+		}
+		ranges = ranges.filter((r, index) => nestingLevels[index] < maxLevel);
+	}
+	return <FoldingRangeList>{ ranges };
+}

extensions/json-language-features/server/src/jsonServerMain.ts

@@ -0,0 +1,379 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import {
+	createConnection, IConnection,
+	TextDocuments, TextDocument, InitializeParams, InitializeResult, NotificationType, RequestType,
+	DocumentRangeFormattingRequest, Disposable, ServerCapabilities, DocumentColorRequest, ColorPresentationRequest
+} from 'vscode-languageserver';
+
+import { xhr, XHRResponse, configure as configureHttpRequests, getErrorStatusDescription } from 'request-light';
+import * as fs from 'fs';
+import URI from 'vscode-uri';
+import * as URL from 'url';
+import { startsWith } from './utils/strings';
+import { formatError, runSafe, runSafeAsync } from './utils/runner';
+import { JSONDocument, JSONSchema, getLanguageService, DocumentLanguageSettings, SchemaConfiguration } from 'vscode-json-languageservice';
+import { getLanguageModelCache } from './languageModelCache';
+import { getFoldingRegions } from './jsonFolding';
+
+import { FoldingRangesRequest, FoldingProviderServerCapabilities } from './protocol/foldingProvider.proposed';
+
+interface ISchemaAssociations {
+	[pattern: string]: string[];
+}
+
+namespace SchemaAssociationNotification {
+	export const type: NotificationType<ISchemaAssociations, any> = new NotificationType('json/schemaAssociations');
+}
+
+namespace VSCodeContentRequest {
+	export const type: RequestType<string, string, any, any> = new RequestType('vscode/content');
+}
+
+namespace SchemaContentChangeNotification {
+	export const type: NotificationType<string, any> = new NotificationType('json/schemaContent');
+}
+
+// Create a connection for the server
+let connection: IConnection = createConnection();
+
+process.on('unhandledRejection', (e: any) => {
+	console.error(formatError(`Unhandled exception`, e));
+});
+process.on('uncaughtException', (e: any) => {
+	console.error(formatError(`Unhandled exception`, e));
+});
+
+
+console.log = connection.console.log.bind(connection.console);
+console.error = connection.console.error.bind(connection.console);
+
+// Create a simple text document manager. The text document manager
+// supports full document sync only
+let documents: TextDocuments = new TextDocuments();
+// Make the text document manager listen on the connection
+// for open, change and close text document events
+documents.listen(connection);
+
+let clientSnippetSupport = false;
+let clientDynamicRegisterSupport = false;
+
+// After the server has started the client sends an initilize request. The server receives
+// in the passed params the rootPath of the workspace plus the client capabilities.
+connection.onInitialize((params: InitializeParams): InitializeResult => {
+
+	function hasClientCapability(...keys: string[]) {
+		let c = params.capabilities as any;
+		for (let i = 0; c && i < keys.length; i++) {
+			c = c[keys[i]];
+		}
+		return !!c;
+	}
+
+	clientSnippetSupport = hasClientCapability('textDocument', 'completion', 'completionItem', 'snippetSupport');
+	clientDynamicRegisterSupport = hasClientCapability('workspace', 'symbol', 'dynamicRegistration');
+	let capabilities: ServerCapabilities & FoldingProviderServerCapabilities = {
+		// Tell the client that the server works in FULL text document sync mode
+		textDocumentSync: documents.syncKind,
+		completionProvider: clientSnippetSupport ? { resolveProvider: true, triggerCharacters: ['"', ':'] } : void 0,
+		hoverProvider: true,
+		documentSymbolProvider: true,
+		documentRangeFormattingProvider: false,
+		colorProvider: true,
+		foldingProvider: true
+	};
+
+	return { capabilities };
+});
+
+let workspaceContext = {
+	resolveRelativePath: (relativePath: string, resource: string) => {
+		return URL.resolve(resource, relativePath);
+	}
+};
+
+let schemaRequestService = (uri: string): Thenable<string> => {
+	if (startsWith(uri, 'file://')) {
+		let fsPath = URI.parse(uri).fsPath;
+		return new Promise<string>((c, e) => {
+			fs.readFile(fsPath, 'UTF-8', (err, result) => {
+				err ? e('') : c(result.toString());
+			});
+		});
+	} else if (startsWith(uri, 'vscode://')) {
+		return connection.sendRequest(VSCodeContentRequest.type, uri).then(responseText => {
+			return responseText;
+		}, error => {
+			return Promise.reject(error.message);
+		});
+	}
+	if (uri.indexOf('//schema.management.azure.com/') !== -1) {
+		/* __GDPR__
+			"json.schema" : {
+				"schemaURL" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
+			}
+		 */
+		connection.telemetry.logEvent({
+			key: 'json.schema',
+			value: {
+				schemaURL: uri
+			}
+		});
+	}
+	let headers = { 'Accept-Encoding': 'gzip, deflate' };
+	return xhr({ url: uri, followRedirects: 5, headers }).then(response => {
+		return response.responseText;
+	}, (error: XHRResponse) => {
+		return Promise.reject(error.responseText || getErrorStatusDescription(error.status) || error.toString());
+	});
+};
+
+// create the JSON language service
+let languageService = getLanguageService({
+	schemaRequestService,
+	workspaceContext,
+	contributions: []
+});
+
+// The settings interface describes the server relevant settings part
+interface Settings {
+	json: {
+		schemas: JSONSchemaSettings[];
+		format: { enable: boolean; };
+	};
+	http: {
+		proxy: string;
+		proxyStrictSSL: boolean;
+	};
+}
+
+interface JSONSchemaSettings {
+	fileMatch?: string[];
+	url?: string;
+	schema?: JSONSchema;
+}
+
+let jsonConfigurationSettings: JSONSchemaSettings[] | undefined = void 0;
+let schemaAssociations: ISchemaAssociations | undefined = void 0;
+let formatterRegistration: Thenable<Disposable> | null = null;
+
+// The settings have changed. Is send on server activation as well.
+connection.onDidChangeConfiguration((change) => {
+	var settings = <Settings>change.settings;
+	configureHttpRequests(settings.http && settings.http.proxy, settings.http && settings.http.proxyStrictSSL);
+
+	jsonConfigurationSettings = settings.json && settings.json.schemas;
+	updateConfiguration();
+
+	// dynamically enable & disable the formatter
+	if (clientDynamicRegisterSupport) {
+		let enableFormatter = settings && settings.json && settings.json.format && settings.json.format.enable;
+		if (enableFormatter) {
+			if (!formatterRegistration) {
+				formatterRegistration = connection.client.register(DocumentRangeFormattingRequest.type, { documentSelector: [{ language: 'json' }, { language: 'jsonc' }] });
+			}
+		} else if (formatterRegistration) {
+			formatterRegistration.then(r => r.dispose());
+			formatterRegistration = null;
+		}
+	}
+});
+
+// The jsonValidation extension configuration has changed
+connection.onNotification(SchemaAssociationNotification.type, associations => {
+	schemaAssociations = associations;
+	updateConfiguration();
+});
+
+// A schema has changed
+connection.onNotification(SchemaContentChangeNotification.type, uri => {
+	languageService.resetSchema(uri);
+});
+
+function updateConfiguration() {
+	let languageSettings = {
+		validate: true,
+		allowComments: true,
+		schemas: new Array<SchemaConfiguration>()
+	};
+	if (schemaAssociations) {
+		for (var pattern in schemaAssociations) {
+			let association = schemaAssociations[pattern];
+			if (Array.isArray(association)) {
+				association.forEach(uri => {
+					languageSettings.schemas.push({ uri, fileMatch: [pattern] });
+				});
+			}
+		}
+	}
+	if (jsonConfigurationSettings) {
+		jsonConfigurationSettings.forEach((schema, index) => {
+			let uri = schema.url;
+			if (!uri && schema.schema) {
+				uri = schema.schema.id || `vscode://schemas/custom/${index}`;
+			}
+			if (uri) {
+				languageSettings.schemas.push({ uri, fileMatch: schema.fileMatch, schema: schema.schema });
+			}
+		});
+	}
+	languageService.configure(languageSettings);
+
+	// Revalidate any open text documents
+	documents.all().forEach(triggerValidation);
+}
+
+// The content of a text document has changed. This event is emitted
+// when the text document first opened or when its content has changed.
+documents.onDidChangeContent((change) => {
+	triggerValidation(change.document);
+});
+
+// a document has closed: clear all diagnostics
+documents.onDidClose(event => {
+	cleanPendingValidation(event.document);
+	connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+});
+
+let pendingValidationRequests: { [uri: string]: NodeJS.Timer; } = {};
+const validationDelayMs = 500;
+
+function cleanPendingValidation(textDocument: TextDocument): void {
+	let request = pendingValidationRequests[textDocument.uri];
+	if (request) {
+		clearTimeout(request);
+		delete pendingValidationRequests[textDocument.uri];
+	}
+}
+
+function triggerValidation(textDocument: TextDocument): void {
+	cleanPendingValidation(textDocument);
+	pendingValidationRequests[textDocument.uri] = setTimeout(() => {
+		delete pendingValidationRequests[textDocument.uri];
+		validateTextDocument(textDocument);
+	}, validationDelayMs);
+}
+
+function validateTextDocument(textDocument: TextDocument): void {
+	if (textDocument.getText().length === 0) {
+		// ignore empty documents
+		connection.sendDiagnostics({ uri: textDocument.uri, diagnostics: [] });
+		return;
+	}
+	let jsonDocument = getJSONDocument(textDocument);
+	let version = textDocument.version;
+
+	let documentSettings: DocumentLanguageSettings = textDocument.languageId === 'jsonc' ? { comments: 'ignore', trailingCommas: 'ignore' } : { comments: 'error', trailingCommas: 'error' };
+	languageService.doValidation(textDocument, jsonDocument, documentSettings).then(diagnostics => {
+		setTimeout(() => {
+			let currDocument = documents.get(textDocument.uri);
+			if (currDocument && currDocument.version === version) {
+				// Send the computed diagnostics to VSCode.
+				connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+			}
+		}, 100);
+	}, error => {
+		connection.console.error(formatError(`Error while validating ${textDocument.uri}`, error));
+	});
+}
+
+connection.onDidChangeWatchedFiles((change) => {
+	// Monitored files have changed in VSCode
+	let hasChanges = false;
+	change.changes.forEach(c => {
+		if (languageService.resetSchema(c.uri)) {
+			hasChanges = true;
+		}
+	});
+	if (hasChanges) {
+		documents.all().forEach(triggerValidation);
+	}
+});
+
+let jsonDocuments = getLanguageModelCache<JSONDocument>(10, 60, document => languageService.parseJSONDocument(document));
+documents.onDidClose(e => {
+	jsonDocuments.onDocumentRemoved(e.document);
+});
+connection.onShutdown(() => {
+	jsonDocuments.dispose();
+});
+
+function getJSONDocument(document: TextDocument): JSONDocument {
+	return jsonDocuments.get(document);
+}
+
+connection.onCompletion((textDocumentPosition, token) => {
+	return runSafeAsync(() => {
+		let document = documents.get(textDocumentPosition.textDocument.uri);
+		let jsonDocument = getJSONDocument(document);
+		return languageService.doComplete(document, textDocumentPosition.position, jsonDocument);
+	}, null, `Error while computing completions for ${textDocumentPosition.textDocument.uri}`, token);
+});
+
+connection.onCompletionResolve((completionItem, token) => {
+	return runSafeAsync(() => {
+		return languageService.doResolve(completionItem);
+	}, completionItem, `Error while resolving completion proposal`, token);
+});
+
+connection.onHover((textDocumentPositionParams, token) => {
+	return runSafeAsync(() => {
+		let document = documents.get(textDocumentPositionParams.textDocument.uri);
+		let jsonDocument = getJSONDocument(document);
+		return languageService.doHover(document, textDocumentPositionParams.position, jsonDocument);
+	}, null, `Error while computing hover for ${textDocumentPositionParams.textDocument.uri}`, token);
+});
+
+connection.onDocumentSymbol((documentSymbolParams, token) => {
+	return runSafe(() => {
+		let document = documents.get(documentSymbolParams.textDocument.uri);
+		let jsonDocument = getJSONDocument(document);
+		return languageService.findDocumentSymbols(document, jsonDocument);
+	}, [], `Error while computing document symbols for ${documentSymbolParams.textDocument.uri}`, token);
+});
+
+connection.onDocumentRangeFormatting((formatParams, token) => {
+	return runSafe(() => {
+		let document = documents.get(formatParams.textDocument.uri);
+		return languageService.format(document, formatParams.range, formatParams.options);
+	}, [], `Error while formatting range for ${formatParams.textDocument.uri}`, token);
+});
+
+connection.onRequest(DocumentColorRequest.type, (params, token) => {
+	return runSafeAsync(() => {
+		let document = documents.get(params.textDocument.uri);
+		if (document) {
+			let jsonDocument = getJSONDocument(document);
+			return languageService.findDocumentColors(document, jsonDocument);
+		}
+		return Promise.resolve([]);
+	}, [], `Error while computing document colors for ${params.textDocument.uri}`, token);
+});
+
+connection.onRequest(ColorPresentationRequest.type, (params, token) => {
+	return runSafe(() => {
+		let document = documents.get(params.textDocument.uri);
+		if (document) {
+			let jsonDocument = getJSONDocument(document);
+			return languageService.getColorPresentations(document, jsonDocument, params.color, params.range);
+		}
+		return [];
+	}, [], `Error while computing color presentations for ${params.textDocument.uri}`, token);
+});
+
+connection.onRequest(FoldingRangesRequest.type, (params, token) => {
+	return runSafe(() => {
+		let document = documents.get(params.textDocument.uri);
+		if (document) {
+			return getFoldingRegions(document, params.maxRanges, token);
+		}
+		return null;
+	}, null, `Error while computing folding ranges for ${params.textDocument.uri}`, token);
+});
+
+// Listen on the connection
+connection.listen();

extensions/json-language-features/server/src/languageModelCache.ts

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { TextDocument } from 'vscode-languageserver';
+
+export interface LanguageModelCache<T> {
+	get(document: TextDocument): T;
+	onDocumentRemoved(document: TextDocument): void;
+	dispose(): void;
+}
+
+export function getLanguageModelCache<T>(maxEntries: number, cleanupIntervalTimeInSec: number, parse: (document: TextDocument) => T): LanguageModelCache<T> {
+	let languageModels: { [uri: string]: { version: number, languageId: string, cTime: number, languageModel: T } } = {};
+	let nModels = 0;
+
+	let cleanupInterval: NodeJS.Timer | undefined = void 0;
+	if (cleanupIntervalTimeInSec > 0) {
+		cleanupInterval = setInterval(() => {
+			let cutoffTime = Date.now() - cleanupIntervalTimeInSec * 1000;
+			let uris = Object.keys(languageModels);
+			for (let uri of uris) {
+				let languageModelInfo = languageModels[uri];
+				if (languageModelInfo.cTime < cutoffTime) {
+					delete languageModels[uri];
+					nModels--;
+				}
+			}
+		}, cleanupIntervalTimeInSec * 1000);
+	}
+
+	return {
+		get(document: TextDocument): T {
+			let version = document.version;
+			let languageId = document.languageId;
+			let languageModelInfo = languageModels[document.uri];
+			if (languageModelInfo && languageModelInfo.version === version && languageModelInfo.languageId === languageId) {
+				languageModelInfo.cTime = Date.now();
+				return languageModelInfo.languageModel;
+			}
+			let languageModel = parse(document);
+			languageModels[document.uri] = { languageModel, version, languageId, cTime: Date.now() };
+			if (!languageModelInfo) {
+				nModels++;
+			}
+
+			if (nModels === maxEntries) {
+				let oldestTime = Number.MAX_VALUE;
+				let oldestUri = null;
+				for (let uri in languageModels) {
+					let languageModelInfo = languageModels[uri];
+					if (languageModelInfo.cTime < oldestTime) {
+						oldestUri = uri;
+						oldestTime = languageModelInfo.cTime;
+					}
+				}
+				if (oldestUri) {
+					delete languageModels[oldestUri];
+					nModels--;
+				}
+			}
+			return languageModel;
+
+		},
+		onDocumentRemoved(document: TextDocument) {
+			let uri = document.uri;
+			if (languageModels[uri]) {
+				delete languageModels[uri];
+				nModels--;
+			}
+		},
+		dispose() {
+			if (typeof cleanupInterval !== 'undefined') {
+				clearInterval(cleanupInterval);
+				cleanupInterval = void 0;
+				languageModels = {};
+				nModels = 0;
+			}
+		}
+	};
+}

extensions/json-language-features/server/src/protocol/foldingProvider.proposed.ts

@@ -0,0 +1,94 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { TextDocumentIdentifier } from 'vscode-languageserver-types';
+import { RequestType, TextDocumentRegistrationOptions, StaticRegistrationOptions } from 'vscode-languageserver-protocol';
+
+// ---- capabilities
+
+export interface FoldingProviderClientCapabilities {
+	/**
+	 * The text document client capabilities
+	 */
+	textDocument?: {
+		/**
+		 * Capabilities specific to the foldingProvider
+		 */
+		foldingProvider?: {
+			/**
+			 * Whether implementation supports dynamic registration. If this is set to `true`
+			 * the client supports the new `(FoldingProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions)`
+			 * return value for the corresponding server capability as well.
+			 */
+			dynamicRegistration?: boolean;
+		};
+	};
+}
+
+export interface FoldingProviderOptions {
+}
+
+export interface FoldingProviderServerCapabilities {
+	/**
+	 * The server provides folding provider support.
+	 */
+	foldingProvider?: FoldingProviderOptions | (FoldingProviderOptions & TextDocumentRegistrationOptions & StaticRegistrationOptions);
+}
+
+export interface FoldingRangeList {
+	/**
+	 * The folding ranges.
+	 */
+	ranges: FoldingRange[];
+}
+
+export enum FoldingRangeType {
+	/**
+	 * Folding range for a comment
+	 */
+	Comment = 'comment',
+	/**
+	 * Folding range for a imports or includes
+	 */
+	Imports = 'imports',
+	/**
+	 * Folding range for a region (e.g. `#region`)
+	 */
+	Region = 'region'
+}
+
+export interface FoldingRange {
+
+	/**
+	 * The start line number
+	 */
+	startLine: number;
+
+	/**
+	 * The end line number
+	 */
+	endLine: number;
+
+	/**
+	 * The actual color value for this folding range.
+	 */
+	type?: FoldingRangeType | string;
+}
+
+export interface FoldingRangeRequestParam {
+	/**
+	 * The text document.
+	 */
+	textDocument: TextDocumentIdentifier;
+
+	/**
+	 * The maximum number of ranges to provide
+	 */
+	maxRanges?: number;
+}
+
+export namespace FoldingRangesRequest {
+	export const type: RequestType<FoldingRangeRequestParam, FoldingRangeList | null, any, any> = new RequestType('textDocument/foldingRanges');
+}

extensions/json-language-features/server/src/test/folding.test.ts

@@ -0,0 +1,144 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import 'mocha';
+import * as assert from 'assert';
+import { TextDocument } from 'vscode-languageserver';
+import { getFoldingRegions } from '../jsonFolding';
+
+interface ExpectedIndentRange {
+	startLine: number;
+	endLine: number;
+	type?: string;
+}
+
+function assertRanges(lines: string[], expected: ExpectedIndentRange[], nRanges?: number): void {
+	let document = TextDocument.create('test://foo/bar.json', 'json', 1, lines.join('\n'));
+	let actual = getFoldingRegions(document, nRanges, null)!.ranges;
+
+	let actualRanges = [];
+	for (let i = 0; i < actual.length; i++) {
+		actualRanges[i] = r(actual[i].startLine, actual[i].endLine, actual[i].type);
+	}
+	actualRanges = actualRanges.sort((r1, r2) => r1.startLine - r2.startLine);
+	assert.deepEqual(actualRanges, expected);
+}
+
+function r(startLine: number, endLine: number, type?: string): ExpectedIndentRange {
+	return { startLine, endLine, type };
+}
+
+suite('Object Folding', () => {
+	test('Fold one level', () => {
+		let input = [
+			/*0*/'{',
+			/*1*/'"foo":"bar"',
+			/*2*/'}'
+		];
+		assertRanges(input, [r(0, 1, 'object')]);
+	});
+
+	test('Fold two level', () => {
+		let input = [
+			/*0*/'[',
+			/*1*/'{',
+			/*2*/'"foo":"bar"',
+			/*3*/'}',
+			/*4*/']'
+		];
+		assertRanges(input, [r(0, 3, 'array'), r(1, 2, 'object')]);
+	});
+
+	test('Fold Arrays', () => {
+		let input = [
+			/*0*/'[',
+			/*1*/'[',
+			/*2*/'],[',
+			/*3*/'1',
+			/*4*/']',
+			/*5*/']'
+		];
+		assertRanges(input, [r(0, 4, 'array'), r(2, 3, 'array')]);
+	});
+
+	test('Filter start on same line', () => {
+		let input = [
+			/*0*/'[[',
+			/*1*/'[',
+			/*2*/'],[',
+			/*3*/'1',
+			/*4*/']',
+			/*5*/']]'
+		];
+		assertRanges(input, [r(0, 4, 'array'), r(2, 3, 'array')]);
+	});
+
+	test('Fold commment', () => {
+		let input = [
+			/*0*/'/*',
+			/*1*/' multi line',
+			/*2*/'*/',
+		];
+		assertRanges(input, [r(0, 2, 'comment')]);
+	});
+
+	test('Incomplete commment', () => {
+		let input = [
+			/*0*/'/*',
+			/*1*/'{',
+			/*2*/'"foo":"bar"',
+			/*3*/'}',
+		];
+		assertRanges(input, [r(1, 2, 'object')]);
+	});
+
+	test('Fold regions', () => {
+		let input = [
+			/*0*/'// #region',
+			/*1*/'{',
+			/*2*/'}',
+			/*3*/'// #endregion',
+		];
+		assertRanges(input, [r(0, 3, 'region')]);
+	});
+
+	test('Test limit', () => {
+		let input = [
+			/* 0*/'[',
+			/* 1*/' [',
+			/* 2*/'  [',
+			/* 3*/'  ',
+			/* 4*/'  ],',
+			/* 5*/'  [',
+			/* 6*/'   [',
+			/* 7*/'  ',
+			/* 8*/'   ],',
+			/* 9*/'   [',
+			/*10*/'  ',
+			/*11*/'   ],',
+			/*12*/'  ],',
+			/*13*/'  [',
+			/*14*/'  ',
+			/*15*/'  ],',
+			/*16*/'  [',
+			/*17*/'  ',
+			/*18*/'  ]',
+			/*19*/' ]',
+			/*20*/']',
+		];
+		assertRanges(input, [r(0, 19, 'array'), r(1, 18, 'array'), r(2, 3, 'array'), r(5, 11, 'array'), r(6, 7, 'array'), r(9, 10, 'array'), r(13, 14, 'array'), r(16, 17, 'array')], void 0);
+		assertRanges(input, [r(0, 19, 'array'), r(1, 18, 'array'), r(2, 3, 'array'), r(5, 11, 'array'), r(6, 7, 'array'), r(9, 10, 'array'), r(13, 14, 'array'), r(16, 17, 'array')], 8);
+		assertRanges(input, [r(0, 19, 'array'), r(1, 18, 'array'), r(2, 3, 'array'), r(5, 11, 'array'), r(13, 14, 'array'), r(16, 17, 'array')], 7);
+		assertRanges(input, [r(0, 19, 'array'), r(1, 18, 'array'), r(2, 3, 'array'), r(5, 11, 'array'), r(13, 14, 'array'), r(16, 17, 'array')], 6);
+		assertRanges(input, [r(0, 19, 'array'), r(1, 18, 'array')], 5);
+		assertRanges(input, [r(0, 19, 'array'), r(1, 18, 'array')], 4);
+		assertRanges(input, [r(0, 19, 'array'), r(1, 18, 'array')], 3);
+		assertRanges(input, [r(0, 19, 'array'), r(1, 18, 'array')], 2);
+		assertRanges(input, [r(0, 19, 'array')], 1);
+	});
+
+});

extensions/json-language-features/server/src/utils/runner.ts

@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import { CancellationToken, ResponseError, ErrorCodes } from 'vscode-languageserver';
+
+export function formatError(message: string, err: any): string {
+	if (err instanceof Error) {
+		let error = <Error>err;
+		return `${message}: ${error.message}\n${error.stack}`;
+	} else if (typeof err === 'string') {
+		return `${message}: ${err}`;
+	} else if (err) {
+		return `${message}: ${err.toString()}`;
+	}
+	return message;
+}
+
+export function runSafeAsync<T>(func: () => Thenable<T>, errorVal: T, errorMessage: string, token: CancellationToken): Thenable<T | ResponseError<any>> {
+	return new Promise<T | ResponseError<any>>((resolve, reject) => {
+		setImmediate(() => {
+			if (token.isCancellationRequested) {
+				resolve(cancelValue());
+			}
+			return func().then(result => {
+				if (token.isCancellationRequested) {
+					resolve(cancelValue());
+					return;
+				} else {
+					resolve(result);
+				}
+			}, e => {
+				console.error(formatError(errorMessage, e));
+				resolve(errorVal);
+			});
+		});
+	});
+}
+
+export function runSafe<T, E>(func: () => T, errorVal: T, errorMessage: string, token: CancellationToken): Thenable<T | ResponseError<E>> {
+	return new Promise<T | ResponseError<E>>((resolve, reject) => {
+		setImmediate(() => {
+			if (token.isCancellationRequested) {
+				resolve(cancelValue());
+			} else {
+				try {
+					let result = func();
+					if (token.isCancellationRequested) {
+						resolve(cancelValue());
+						return;
+					} else {
+						resolve(result);
+					}
+
+				} catch (e) {
+					console.error(formatError(errorMessage, e));
+					resolve(errorVal);
+				}
+			}
+		});
+	});
+}
+
+function cancelValue<E>() {
+	console.log('cancelled');
+	return new ResponseError<E>(ErrorCodes.RequestCancelled, 'Request cancelled');
+}

extensions/json-language-features/server/src/utils/strings.ts

@@ -0,0 +1,37 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+export function startsWith(haystack: string, needle: string): boolean {
+	if (haystack.length < needle.length) {
+		return false;
+	}
+
+	for (let i = 0; i < needle.length; i++) {
+		if (haystack[i] !== needle[i]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * Determines if haystack ends with needle.
+ */
+export function endsWith(haystack: string, needle: string): boolean {
+	let diff = haystack.length - needle.length;
+	if (diff > 0) {
+		return haystack.lastIndexOf(needle) === diff;
+	} else if (diff === 0) {
+		return haystack === needle;
+	} else {
+		return false;
+	}
+}
+
+export function convertSimple2RegExpPattern(pattern: string): string {
+	return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
+}