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/markdown/src/test/index.ts

@@ -0,0 +1,28 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+//
+// PLEASE DO NOT MODIFY / DELETE UNLESS YOU KNOW WHAT YOU ARE DOING
+//
+// This file is providing the test runner to use when running extension tests.
+// By default the test runner in use is Mocha based.
+//
+// You can provide your own test runner if you want to override it by exporting
+// a function run(testRoot: string, clb: (error:Error) => void) that the extension
+// host can call to run the tests. The test runner is expected to use console.log
+// to report the results back to the caller. When the tests are finished, return
+// a possible error to the callback or null if none.
+
+const testRunner = require('vscode/lib/testrunner');
+
+// You can directly control Mocha options by uncommenting the following lines
+// See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
+testRunner.configure({
+	ui: 'tdd', 		// the TDD UI is being used in extension.test.ts (suite, test, etc.)
+	useColors: process.platform !== 'win32', // colored output from test results (only windows cannot handle)
+	timeout: 60000
+});
+
+export = testRunner;

extensions/markdown/src/test/tableOfContentsProvider.test.ts

@@ -0,0 +1,131 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import 'mocha';
+
+import { TableOfContentsProvider } from '../tableOfContentsProvider';
+import { MarkdownEngine } from '../markdownEngine';
+
+const testFileName = vscode.Uri.parse('test.md');
+
+suite('markdown.TableOfContentsProvider', () => {
+	test('Lookup should not return anything for empty document', async () => {
+		const doc = new InMemoryDocument(testFileName, '');
+		const provider = new TableOfContentsProvider(new MarkdownEngine(), doc);
+
+		assert.strictEqual(await provider.lookup(''), undefined);
+		assert.strictEqual(await provider.lookup('foo'), undefined);
+	});
+
+	test('Lookup should not return anything for document with no headers', async () => {
+		const doc = new InMemoryDocument(testFileName, 'a *b*\nc');
+		const provider = new TableOfContentsProvider(new MarkdownEngine(), doc);
+
+		assert.strictEqual(await provider.lookup(''), undefined);
+		assert.strictEqual(await provider.lookup('foo'), undefined);
+		assert.strictEqual(await provider.lookup('a'), undefined);
+		assert.strictEqual(await provider.lookup('b'), undefined);
+	});
+
+	test('Lookup should return basic #header', async () => {
+		const doc = new InMemoryDocument(testFileName, `# a\nx\n# c`);
+		const provider = new TableOfContentsProvider(new MarkdownEngine(), doc);
+
+		{
+			const entry = await provider.lookup('a');
+			assert.ok(entry);
+			assert.strictEqual(entry!.line, 0);
+		}
+		{
+			assert.strictEqual(await provider.lookup('x'), undefined);
+		}
+		{
+			const entry = await provider.lookup('c');
+			assert.ok(entry);
+			assert.strictEqual(entry!.line, 2);
+		}
+	});
+
+	test('Lookups should be case in-sensitive', async () => {
+		const doc = new InMemoryDocument(testFileName, `# fOo\n`);
+		const provider = new TableOfContentsProvider(new MarkdownEngine(), doc);
+
+		assert.strictEqual((await provider.lookup('fOo'))!.line, 0);
+		assert.strictEqual((await provider.lookup('foo'))!.line, 0);
+		assert.strictEqual((await provider.lookup('FOO'))!.line, 0);
+	});
+
+	test('Lookups should ignore leading and trailing white-space, and collapse internal whitespace', async () => {
+		const doc = new InMemoryDocument(testFileName, `#      f o  o    \n`);
+		const provider = new TableOfContentsProvider(new MarkdownEngine(), doc);
+
+		assert.strictEqual((await provider.lookup('f o  o'))!.line, 0);
+		assert.strictEqual((await provider.lookup('  f o  o'))!.line, 0);
+		assert.strictEqual((await provider.lookup('  f o  o  '))!.line, 0);
+		assert.strictEqual((await provider.lookup('f o o'))!.line, 0);
+		assert.strictEqual((await provider.lookup('f o       o'))!.line, 0);
+
+		assert.strictEqual(await provider.lookup('f'), undefined);
+		assert.strictEqual(await provider.lookup('foo'), undefined);
+		assert.strictEqual(await provider.lookup('fo o'), undefined);
+	});
+});
+
+class InMemoryDocument implements vscode.TextDocument {
+	private readonly _lines: string[];
+
+	constructor(
+		public readonly uri: vscode.Uri,
+		private readonly _contents: string
+	) {
+		this._lines = this._contents.split(/\n/g);
+	}
+
+	fileName: string = '';
+	isUntitled: boolean = false;
+	languageId: string = '';
+	version: number = 1;
+	isDirty: boolean = false;
+	isClosed: boolean = false;
+	eol: vscode.EndOfLine = vscode.EndOfLine.LF;
+
+	get lineCount(): number {
+		return this._lines.length;
+	}
+
+	lineAt(line: any): vscode.TextLine {
+		return {
+			lineNumber: line,
+			text: this._lines[line],
+			range: new vscode.Range(0, 0, 0, 0),
+			firstNonWhitespaceCharacterIndex: 0,
+			rangeIncludingLineBreak: new vscode.Range(0, 0, 0, 0),
+			isEmptyOrWhitespace: false
+		};
+	}
+	offsetAt(_position: vscode.Position): never {
+		throw new Error('Method not implemented.');
+	}
+	positionAt(_offset: number): never {
+		throw new Error('Method not implemented.');
+	}
+	getText(_range?: vscode.Range | undefined): string {
+		return this._contents;
+	}
+	getWordRangeAtPosition(_position: vscode.Position, _regex?: RegExp | undefined): never {
+		throw new Error('Method not implemented.');
+	}
+	validateRange(_range: vscode.Range): never {
+		throw new Error('Method not implemented.');
+	}
+	validatePosition(_position: vscode.Position): never {
+		throw new Error('Method not implemented.');
+	}
+	save(): never {
+		throw new Error('Method not implemented.');
+	}
+}