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

src/vs/platform/keybinding/common/keybindingResolver.ts

@@ -5,7 +5,7 @@
 'use strict';
 
 import { isFalsyOrEmpty } from 'vs/base/common/arrays';
-import { ContextKeyExpr, IContext } from 'vs/platform/contextkey/common/contextkey';
+import { ContextKeyExpr, IContext, ContextKeyAndExpr } from 'vs/platform/contextkey/common/contextkey';
 import { ResolvedKeybindingItem } from 'vs/platform/keybinding/common/resolvedKeybindingItem';
 import { CommandsRegistry, ICommandHandlerDescription } from 'vs/platform/commands/common/commands';
 
@@ -121,7 +121,7 @@ export class KeybindingResolver {
 				continue;
 			}
 
-			if (KeybindingResolver.whenIsEntirelyIncluded(true, conflict.when, item.when)) {
+			if (KeybindingResolver.whenIsEntirelyIncluded(conflict.when, item.when)) {
 				// `item` completely overwrites `conflict`
 				// Remove conflict from the lookupMap
 				this._removeFromLookupMap(conflict);
@@ -160,15 +160,10 @@ export class KeybindingResolver {
 	}
 
 	/**
-	 * Returns true if `a` is completely covered by `b`.
-	 * Returns true if `b` is a more relaxed `a`.
-	 * Return true if (`a` === true implies `b` === true).
+	 * Returns true if it is provable `a` implies `b`.
+	 * **Precondition**: Assumes `a` and `b` are normalized!
 	 */
-	public static whenIsEntirelyIncluded(inNormalizedForm: boolean, a: ContextKeyExpr, b: ContextKeyExpr): boolean {
-		if (!inNormalizedForm) {
-			a = a ? a.normalize() : null;
-			b = b ? b.normalize() : null;
-		}
+	public static whenIsEntirelyIncluded(a: ContextKeyExpr, b: ContextKeyExpr): boolean {
 		if (!b) {
 			return true;
 		}
@@ -176,16 +171,22 @@ export class KeybindingResolver {
 			return false;
 		}
 
-		let aRulesArr = a.serialize().split(' && ');
-		let bRulesArr = b.serialize().split(' && ');
+		const aExpressions: ContextKeyExpr[] = ((a instanceof ContextKeyAndExpr) ? a.expr : [a]);
+		const bExpressions: ContextKeyExpr[] = ((b instanceof ContextKeyAndExpr) ? b.expr : [b]);
 
-		let aRules: { [rule: string]: boolean; } = Object.create(null);
-		for (let i = 0, len = aRulesArr.length; i < len; i++) {
-			aRules[aRulesArr[i]] = true;
-		}
+		let aIndex = 0;
+		for (let bIndex = 0; bIndex < bExpressions.length; bIndex++) {
+			let bExpr = bExpressions[bIndex];
+			let bExprMatched = false;
+			while (!bExprMatched && aIndex < aExpressions.length) {
+				let aExpr = aExpressions[aIndex];
+				if (aExpr.equals(bExpr)) {
+					bExprMatched = true;
+				}
+				aIndex++;
+			}
 
-		for (let i = 0, len = bRulesArr.length; i < len; i++) {
-			if (!aRules[bRulesArr[i]]) {
+			if (!bExprMatched) {
 				return false;
 			}
 		}

src/vs/platform/keybinding/common/keybindingsRegistry.ts

@@ -75,6 +75,7 @@ export interface IKeybindingsRegistry {
 class KeybindingsRegistryImpl implements IKeybindingsRegistry {
 
 	private _keybindings: IKeybindingItem[];
+	private _keybindingsSorted: boolean;
 
 	public WEIGHT = {
 		editorCore: (importance: number = 0): number => {
@@ -96,6 +97,7 @@ class KeybindingsRegistryImpl implements IKeybindingsRegistry {
 
 	constructor() {
 		this._keybindings = [];
+		this._keybindingsSorted = true;
 	}
 
 	/**
@@ -144,11 +146,14 @@ class KeybindingsRegistryImpl implements IKeybindingsRegistry {
 		let actualKb = KeybindingsRegistryImpl.bindToCurrentPlatform(rule);
 
 		if (actualKb && actualKb.primary) {
-			this.registerDefaultKeybinding(createKeybinding(actualKb.primary, OS), rule.id, rule.weight, 0, rule.when);
+			this._registerDefaultKeybinding(createKeybinding(actualKb.primary, OS), rule.id, rule.weight, 0, rule.when);
 		}
 
 		if (actualKb && Array.isArray(actualKb.secondary)) {
-			actualKb.secondary.forEach((k, i) => this.registerDefaultKeybinding(createKeybinding(k, OS), rule.id, rule.weight, -i - 1, rule.when));
+			for (let i = 0, len = actualKb.secondary.length; i < len; i++) {
+				const k = actualKb.secondary[i];
+				this._registerDefaultKeybinding(createKeybinding(k, OS), rule.id, rule.weight, -i - 1, rule.when);
+			}
 		}
 	}
 
@@ -156,7 +161,7 @@ class KeybindingsRegistryImpl implements IKeybindingsRegistry {
 		let actualKb = KeybindingsRegistryImpl.bindToCurrentPlatform2(rule);
 
 		if (actualKb && actualKb.primary) {
-			this.registerDefaultKeybinding(actualKb.primary, rule.id, rule.weight, 0, rule.when);
+			this._registerDefaultKeybinding(actualKb.primary, rule.id, rule.weight, 0, rule.when);
 		}
 	}
 
@@ -199,7 +204,7 @@ class KeybindingsRegistryImpl implements IKeybindingsRegistry {
 		}
 	}
 
-	private registerDefaultKeybinding(keybinding: Keybinding, commandId: string, weight1: number, weight2: number, when: ContextKeyExpr): void {
+	private _registerDefaultKeybinding(keybinding: Keybinding, commandId: string, weight1: number, weight2: number, when: ContextKeyExpr): void {
 		if (OS === OperatingSystem.Windows) {
 			if (keybinding.type === KeybindingType.Chord) {
 				this._assertNoCtrlAlt(keybinding.firstPart, commandId);
@@ -215,12 +220,15 @@ class KeybindingsRegistryImpl implements IKeybindingsRegistry {
 			weight1: weight1,
 			weight2: weight2
 		});
+		this._keybindingsSorted = false;
 	}
 
 	public getDefaultKeybindings(): IKeybindingItem[] {
-		let result = this._keybindings.slice(0);
-		result.sort(sorter);
-		return result;
+		if (!this._keybindingsSorted) {
+			this._keybindings.sort(sorter);
+			this._keybindingsSorted = true;
+		}
+		return this._keybindings.slice(0);
 	}
 }
 export const KeybindingsRegistry: IKeybindingsRegistry = new KeybindingsRegistryImpl();

src/vs/platform/keybinding/test/common/abstractKeybindingService.test.ts

@@ -124,8 +124,8 @@ suite('AbstractKeybindingService', () => {
 			let messageService: IMessageService = {
 				_serviceBrand: undefined,
 				hideAll: undefined,
-				confirmSync: undefined,
 				confirm: undefined,
+				confirmWithCheckbox: undefined,
 				show: (sev: Severity, message: any): () => void => {
 					showMessageCalls.push({
 						sev: sev,

src/vs/platform/keybinding/test/common/keybindingResolver.test.ts

@@ -28,7 +28,7 @@ suite('KeybindingResolver', () => {
 			resolvedKeybinding,
 			command,
 			commandArgs,
-			when,
+			when ? when.normalize() : null,
 			isDefault
 		);
 	}
@@ -194,10 +194,14 @@ suite('KeybindingResolver', () => {
 
 	test('contextIsEntirelyIncluded', function () {
 		let assertIsIncluded = (a: ContextKeyExpr[], b: ContextKeyExpr[]) => {
-			assert.equal(KeybindingResolver.whenIsEntirelyIncluded(false, new ContextKeyAndExpr(a), new ContextKeyAndExpr(b)), true);
+			let tmpA = new ContextKeyAndExpr(a).normalize();
+			let tmpB = new ContextKeyAndExpr(b).normalize();
+			assert.equal(KeybindingResolver.whenIsEntirelyIncluded(tmpA, tmpB), true);
 		};
 		let assertIsNotIncluded = (a: ContextKeyExpr[], b: ContextKeyExpr[]) => {
-			assert.equal(KeybindingResolver.whenIsEntirelyIncluded(false, new ContextKeyAndExpr(a), new ContextKeyAndExpr(b)), false);
+			let tmpA = new ContextKeyAndExpr(a).normalize();
+			let tmpB = new ContextKeyAndExpr(b).normalize();
+			assert.equal(KeybindingResolver.whenIsEntirelyIncluded(tmpA, tmpB), false);
 		};
 		let key1IsTrue = ContextKeyExpr.equals('key1', true);
 		let key1IsNotFalse = ContextKeyExpr.notEquals('key1', false);

src/vs/platform/keybinding/test/common/mockKeybindingService.ts

@@ -7,19 +7,17 @@
 import { ResolvedKeybinding, Keybinding, SimpleKeybinding } from 'vs/base/common/keyCodes';
 import Event from 'vs/base/common/event';
 import { IKeybindingService, IKeybindingEvent, IKeyboardEvent } from 'vs/platform/keybinding/common/keybinding';
-import { IContextKey, IContextKeyService, IContextKeyServiceTarget, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
+import { IContextKey, IContextKeyService, IContextKeyServiceTarget, ContextKeyExpr, IContextKeyChangeEvent } from 'vs/platform/contextkey/common/contextkey';
 import { IResolveResult } from 'vs/platform/keybinding/common/keybindingResolver';
 import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayoutResolvedKeybinding';
 import { OS } from 'vs/base/common/platform';
 import { ResolvedKeybindingItem } from 'vs/platform/keybinding/common/resolvedKeybindingItem';
 
 class MockKeybindingContextKey<T> implements IContextKey<T> {
-	private _key: string;
 	private _defaultValue: T;
 	private _value: T;
 
-	constructor(key: string, defaultValue: T) {
-		this._key = key;
+	constructor(defaultValue: T) {
 		this._defaultValue = defaultValue;
 		this._value = this._defaultValue;
 	}
@@ -46,14 +44,14 @@ export class MockContextKeyService implements IContextKeyService {
 		//
 	}
 	public createKey<T>(key: string, defaultValue: T): IContextKey<T> {
-		let ret = new MockKeybindingContextKey(key, defaultValue);
+		let ret = new MockKeybindingContextKey(defaultValue);
 		this._keys.set(key, ret);
 		return ret;
 	}
 	public contextMatchesRules(rules: ContextKeyExpr): boolean {
 		return false;
 	}
-	public get onDidChangeContext(): Event<string[]> {
+	public get onDidChangeContext(): Event<IContextKeyChangeEvent> {
 		return Event.None;
 	}
 	public getContextKeyValue(key: string) {