Merge VS Code 1.21 source code (#1067)

* Initial VS Code 1.21 file copy with patches

* A few more merges

* Post npm install

* Fix batch of build breaks

* Fix more build breaks

* Fix more build errors

* Fix more build breaks

* Runtime fixes 1

* Get connection dialog working with some todos

* Fix a few packaging issues

* Copy several node_modules to package build to fix loader issues

* Fix breaks from master

* A few more fixes

* Make tests pass

* First pass of license header updates

* Second pass of license header updates

* Fix restore dialog issues

* Remove add additional themes menu items

* fix select box issues where the list doesn't show up

* formatting

* Fix editor dispose issue

* Copy over node modules to correct location on all platforms

extensions/json/server/src/jsonServerMain.ts

@@ -17,12 +17,12 @@ import fs = require('fs');
 import URI from 'vscode-uri';
 import * as URL from 'url';
 import Strings = require('./utils/strings');
-import { formatError, runSafe } from './utils/errors';
-import { JSONDocument, JSONSchema, LanguageSettings, getLanguageService, DocumentLanguageSettings } from 'vscode-json-languageservice';
+import { formatError, runSafe, runSafeAsync } from './utils/errors';
+import { JSONDocument, JSONSchema, getLanguageService, DocumentLanguageSettings, SchemaConfiguration } from 'vscode-json-languageservice';
 import { getLanguageModelCache } from './languageModelCache';
+import { createScanner, SyntaxKind } from 'jsonc-parser';
 
-import * as nls from 'vscode-nls';
-nls.config(process.env['VSCODE_NLS_CONFIG']);
+import { FoldingRangeType, FoldingRangesRequest, FoldingRange, FoldingRangeList, FoldingProviderServerCapabilities } from './protocol/foldingProvider.proposed';
 
 interface ISchemaAssociations {
 	[pattern: string]: string[];
@@ -43,7 +43,7 @@ namespace SchemaContentChangeNotification {
 // Create a connection for the server
 let connection: IConnection = createConnection();
 
-process.on('unhandledRejection', e => {
+process.on('unhandledRejection', (e: any) => {
 	connection.console.error(formatError(`Unhandled exception`, e));
 });
 
@@ -65,7 +65,7 @@ let clientDynamicRegisterSupport = false;
 connection.onInitialize((params: InitializeParams): InitializeResult => {
 
 	function hasClientCapability(...keys: string[]) {
-		let c = params.capabilities;
+		let c = params.capabilities as any;
 		for (let i = 0; c && i < keys.length; i++) {
 			c = c[keys[i]];
 		}
@@ -74,14 +74,15 @@ connection.onInitialize((params: InitializeParams): InitializeResult => {
 
 	clientSnippetSupport = hasClientCapability('textDocument', 'completion', 'completionItem', 'snippetSupport');
 	clientDynamicRegisterSupport = hasClientCapability('workspace', 'symbol', 'dynamicRegistration');
-	let capabilities: ServerCapabilities & CPServerCapabilities = {
+	let capabilities: ServerCapabilities & CPServerCapabilities & FoldingProviderServerCapabilities = {
 		// Tell the client that the server works in FULL text document sync mode
 		textDocumentSync: documents.syncKind,
-		completionProvider: clientSnippetSupport ? { resolveProvider: true, triggerCharacters: ['"', ':'] } : null,
+		completionProvider: clientSnippetSupport ? { resolveProvider: true, triggerCharacters: ['"', ':'] } : void 0,
 		hoverProvider: true,
 		documentSymbolProvider: true,
 		documentRangeFormattingProvider: false,
-		colorProvider: true
+		colorProvider: true,
+		foldingProvider: true
 	};
 
 	return { capabilities };
@@ -105,7 +106,7 @@ let schemaRequestService = (uri: string): Thenable<string> => {
 		return connection.sendRequest(VSCodeContentRequest.type, uri).then(responseText => {
 			return responseText;
 		}, error => {
-			return error.message;
+			return Promise.reject(error.message);
 		});
 	}
 	if (uri.indexOf('//schema.management.azure.com/') !== -1) {
@@ -149,9 +150,9 @@ interface JSONSchemaSettings {
 	schema?: JSONSchema;
 }
 
-let jsonConfigurationSettings: JSONSchemaSettings[] = void 0;
-let schemaAssociations: ISchemaAssociations = void 0;
-let formatterRegistration: Thenable<Disposable> = null;
+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) => {
@@ -187,10 +188,10 @@ connection.onNotification(SchemaContentChangeNotification.type, uri => {
 });
 
 function updateConfiguration() {
-	let languageSettings: LanguageSettings = {
+	let languageSettings = {
 		validate: true,
 		allowComments: true,
-		schemas: []
+		schemas: new Array<SchemaConfiguration>()
 	};
 	if (schemaAssociations) {
 		for (var pattern in schemaAssociations) {
@@ -232,7 +233,7 @@ documents.onDidClose(event => {
 });
 
 let pendingValidationRequests: { [uri: string]: NodeJS.Timer; } = {};
-const validationDelayMs = 200;
+const validationDelayMs = 500;
 
 function cleanPendingValidation(textDocument: TextDocument): void {
 	let request = pendingValidationRequests[textDocument.uri];
@@ -295,7 +296,7 @@ function getJSONDocument(document: TextDocument): JSONDocument {
 }
 
 connection.onCompletion(textDocumentPosition => {
-	return runSafe(() => {
+	return runSafeAsync(() => {
 		let document = documents.get(textDocumentPosition.textDocument.uri);
 		let jsonDocument = getJSONDocument(document);
 		return languageService.doComplete(document, textDocumentPosition.position, jsonDocument);
@@ -303,13 +304,13 @@ connection.onCompletion(textDocumentPosition => {
 });
 
 connection.onCompletionResolve(completionItem => {
-	return runSafe(() => {
+	return runSafeAsync(() => {
 		return languageService.doResolve(completionItem);
-	}, null, `Error while resolving completion proposal`);
+	}, completionItem, `Error while resolving completion proposal`);
 });
 
 connection.onHover(textDocumentPositionParams => {
-	return runSafe(() => {
+	return runSafeAsync(() => {
 		let document = documents.get(textDocumentPositionParams.textDocument.uri);
 		let jsonDocument = getJSONDocument(document);
 		return languageService.doHover(document, textDocumentPositionParams.position, jsonDocument);
@@ -332,13 +333,13 @@ connection.onDocumentRangeFormatting(formatParams => {
 });
 
 connection.onRequest(DocumentColorRequest.type, params => {
-	return runSafe(() => {
+	return runSafeAsync(() => {
 		let document = documents.get(params.textDocument.uri);
 		if (document) {
 			let jsonDocument = getJSONDocument(document);
 			return languageService.findDocumentColors(document, jsonDocument);
 		}
-		return [];
+		return Promise.resolve([]);
 	}, [], `Error while computing document colors for ${params.textDocument.uri}`);
 });
 
@@ -350,7 +351,86 @@ connection.onRequest(ColorPresentationRequest.type, params => {
 			return languageService.getColorPresentations(document, jsonDocument, params.color, params.range);
 		}
 		return [];
-	}, [], `Error while computing color presentationsd for ${params.textDocument.uri}`);
+	}, [], `Error while computing color presentations for ${params.textDocument.uri}`);
+});
+
+connection.onRequest(FoldingRangesRequest.type, params => {
+	return runSafe(() => {
+		let document = documents.get(params.textDocument.uri);
+		if (document) {
+			let ranges: FoldingRange[] = [];
+			let stack: FoldingRange[] = [];
+			let prevStart = -1;
+			let scanner = createScanner(document.getText(), false);
+			let token = scanner.scan();
+			while (token !== SyntaxKind.EOF) {
+				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;
+								ranges.push(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 (startLine < endLine) {
+							ranges.push({ 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;
+										ranges.push(range);
+										prevStart = range.startLine;
+									}
+								}
+							}
+						}
+						break;
+					}
+
+				}
+				token = scanner.scan();
+			}
+			return <FoldingRangeList>{ ranges };
+		}
+		return null;
+	}, null, `Error while computing folding ranges for ${params.textDocument.uri}`);
 });
 
 // Listen on the connection