Initial VS Code 1.19 source merge (#571)

* Initial 1.19 xcopy

* Fix yarn build

* Fix numerous build breaks

* Next batch of build break fixes

* More build break fixes

* Runtime breaks

* Additional post merge fixes

* Fix windows setup file

* Fix test failures.

* Update license header blocks to refer to source eula

extensions/json/server/src/jsonServerMain.ts

@@ -17,7 +17,8 @@ import fs = require('fs');
 import URI from 'vscode-uri';
 import * as URL from 'url';
 import Strings = require('./utils/strings');
-import { JSONDocument, JSONSchema, LanguageSettings, getLanguageService } from 'vscode-json-languageservice';
+import { formatError, runSafe } from './utils/errors';
+import { JSONDocument, JSONSchema, LanguageSettings, getLanguageService, DocumentLanguageSettings } from 'vscode-json-languageservice';
 import { getLanguageModelCache } from './languageModelCache';
 
 import * as nls from 'vscode-nls';
@@ -42,6 +43,10 @@ namespace SchemaContentChangeNotification {
 // Create a connection for the server
 let connection: IConnection = createConnection();
 
+process.on('unhandledRejection', e => {
+	connection.console.error(formatError(`Unhandled exception`, e));
+});
+
 console.log = connection.console.log.bind(connection.console);
 console.error = connection.console.error.bind(connection.console);
 
@@ -161,7 +166,7 @@ connection.onDidChangeConfiguration((change) => {
 		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' }] });
+				formatterRegistration = connection.client.register(DocumentRangeFormattingRequest.type, { documentSelector: [{ language: 'json' }, { language: 'jsonc' }] });
 			}
 		} else if (formatterRegistration) {
 			formatterRegistration.then(r => r.dispose());
@@ -251,12 +256,17 @@ function validateTextDocument(textDocument: TextDocument): void {
 		connection.sendDiagnostics({ uri: textDocument.uri, diagnostics: [] });
 		return;
 	}
+	try {
+		let jsonDocument = getJSONDocument(textDocument);
 
-	let jsonDocument = getJSONDocument(textDocument);
-	languageService.doValidation(textDocument, jsonDocument).then(diagnostics => {
-		// Send the computed diagnostics to VSCode.
-		connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
-	});
+		let documentSettings: DocumentLanguageSettings = textDocument.languageId === 'jsonc' ? { comments: 'ignore', trailingCommas: 'ignore' } : { comments: 'error', trailingCommas: 'error' };
+		languageService.doValidation(textDocument, jsonDocument, documentSettings).then(diagnostics => {
+			// Send the computed diagnostics to VSCode.
+			connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+		});
+	} catch (e) {
+		connection.console.error(formatError(`Error while validating ${textDocument.uri}`, e));
+	}
 }
 
 connection.onDidChangeWatchedFiles((change) => {
@@ -285,48 +295,62 @@ function getJSONDocument(document: TextDocument): JSONDocument {
 }
 
 connection.onCompletion(textDocumentPosition => {
-	let document = documents.get(textDocumentPosition.textDocument.uri);
-	let jsonDocument = getJSONDocument(document);
-	return languageService.doComplete(document, textDocumentPosition.position, jsonDocument);
+	return runSafe(() => {
+		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}`);
 });
 
 connection.onCompletionResolve(completionItem => {
-	return languageService.doResolve(completionItem);
+	return runSafe(() => {
+		return languageService.doResolve(completionItem);
+	}, null, `Error while resolving completion proposal`);
 });
 
 connection.onHover(textDocumentPositionParams => {
-	let document = documents.get(textDocumentPositionParams.textDocument.uri);
-	let jsonDocument = getJSONDocument(document);
-	return languageService.doHover(document, textDocumentPositionParams.position, jsonDocument);
+	return runSafe(() => {
+		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}`);
 });
 
 connection.onDocumentSymbol(documentSymbolParams => {
-	let document = documents.get(documentSymbolParams.textDocument.uri);
-	let jsonDocument = getJSONDocument(document);
-	return languageService.findDocumentSymbols(document, jsonDocument);
+	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}`);
 });
 
 connection.onDocumentRangeFormatting(formatParams => {
-	let document = documents.get(formatParams.textDocument.uri);
-	return languageService.format(document, formatParams.range, formatParams.options);
+	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}`);
 });
 
 connection.onRequest(DocumentColorRequest.type, params => {
-	let document = documents.get(params.textDocument.uri);
-	if (document) {
-		let jsonDocument = getJSONDocument(document);
-		return languageService.findDocumentColors(document, jsonDocument);
-	}
-	return [];
+	return runSafe(() => {
+		let document = documents.get(params.textDocument.uri);
+		if (document) {
+			let jsonDocument = getJSONDocument(document);
+			return languageService.findDocumentColors(document, jsonDocument);
+		}
+		return [];
+	}, [], `Error while computing document colors for ${params.textDocument.uri}`);
 });
 
 connection.onRequest(ColorPresentationRequest.type, params => {
-	let document = documents.get(params.textDocument.uri);
-	if (document) {
-		let jsonDocument = getJSONDocument(document);
-		return languageService.getColorPresentations(document, jsonDocument, params.color, params.range);
-	}
-	return [];
+	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 presentationsd for ${params.textDocument.uri}`);
 });
 
 // Listen on the connection

extensions/json/server/src/utils/errors.ts

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+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 runSafe<T>(func: () => Thenable<T> | T, errorVal: T, errorMessage: string): Thenable<T> | T {
+	try {
+		let t = func();
+		if (t instanceof Promise) {
+			return t.then(void 0, e => {
+				console.error(formatError(errorMessage, e));
+				return errorVal;
+			});
+		}
+		return t;
+	} catch (e) {
+		console.error(formatError(errorMessage, e));
+		return errorVal;
+	}
+}