Merge VS Code 1.31.1 (#4283)

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

@@ -93,12 +93,16 @@ export abstract class AbstractKeybindingService extends Disposable implements IK
 		);
 	}
 
-	public lookupKeybinding(commandId: string): ResolvedKeybinding | null {
+	public lookupKeybinding(commandId: string): ResolvedKeybinding | undefined {
 		let result = this._getResolver().lookupPrimaryKeybinding(commandId);
 		if (!result) {
-			return null;
+			return undefined;
 		}
-		return result.resolvedKeybinding;
+		return result.resolvedKeybinding || undefined;
+	}
+
+	public dispatchEvent(e: IKeyboardEvent, target: IContextKeyServiceTarget): boolean {
+		return this._dispatch(e, target);
 	}
 
 	public softDispatch(e: IKeyboardEvent, target: IContextKeyServiceTarget): IResolveResult | null {
@@ -152,10 +156,20 @@ export abstract class AbstractKeybindingService extends Disposable implements IK
 		this._currentChord = null;
 	}
 
+	public dispatchByUserSettingsLabel(userSettingsLabel: string, target: IContextKeyServiceTarget): void {
+		const keybindings = this.resolveUserBinding(userSettingsLabel);
+		if (keybindings.length >= 1) {
+			this._doDispatch(keybindings[0], target);
+		}
+	}
+
 	protected _dispatch(e: IKeyboardEvent, target: IContextKeyServiceTarget): boolean {
+		return this._doDispatch(this.resolveKeyboardEvent(e), target);
+	}
+
+	private _doDispatch(keybinding: ResolvedKeybinding, target: IContextKeyServiceTarget): boolean {
 		let shouldPreventDefault = false;
 
-		const keybinding = this.resolveKeyboardEvent(e);
 		if (keybinding.isChord()) {
 			console.warn('Unexpected keyboard event mapped to a chord');
 			return false;

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

@@ -52,11 +52,18 @@ export interface IKeybindingService {
 
 	resolveUserBinding(userBinding: string): ResolvedKeybinding[];
 
+	/**
+	 * Resolve and dispatch `keyboardEvent` and invoke the command.
+	 */
+	dispatchEvent(e: IKeyboardEvent, target: IContextKeyServiceTarget): boolean;
+
 	/**
 	 * Resolve and dispatch `keyboardEvent`, but do not invoke the command or change inner state.
 	 */
 	softDispatch(keyboardEvent: IKeyboardEvent, target: IContextKeyServiceTarget): IResolveResult | null;
 
+	dispatchByUserSettingsLabel(userSettingsLabel: string, target: IContextKeyServiceTarget): void;
+
 	/**
 	 * Look up keybindings for a command.
 	 * Use `lookupKeybinding` if you are interested in the preferred keybinding.
@@ -67,7 +74,7 @@ export interface IKeybindingService {
 	 * Look up the preferred (last defined) keybinding for a command.
 	 * @returns The preferred keybinding or null if the command is not bound.
 	 */
-	lookupKeybinding(commandId: string): ResolvedKeybinding | null;
+	lookupKeybinding(commandId: string): ResolvedKeybinding | undefined;
 
 	getDefaultKeybindingsContent(): string;
 

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

@@ -77,8 +77,7 @@ export class KeybindingResolver {
 	public static combine(defaults: ResolvedKeybindingItem[], rawOverrides: ResolvedKeybindingItem[]): ResolvedKeybindingItem[] {
 		defaults = defaults.slice(0);
 		let overrides: ResolvedKeybindingItem[] = [];
-		for (let i = 0, len = rawOverrides.length; i < len; i++) {
-			const override = rawOverrides[i];
+		for (const override of rawOverrides) {
 			if (!override.command || override.command.length === 0 || override.command.charAt(0) !== '-') {
 				overrides.push(override);
 				continue;
@@ -180,8 +179,7 @@ export class KeybindingResolver {
 		const bExpressions: ContextKeyExpr[] = ((b instanceof ContextKeyAndExpr) ? b.expr : [b]);
 
 		let aIndex = 0;
-		for (let bIndex = 0; bIndex < bExpressions.length; bIndex++) {
-			let bExpr = bExpressions[bIndex];
+		for (const bExpr of bExpressions) {
 			let bExprMatched = false;
 			while (!bExprMatched && aIndex < aExpressions.length) {
 				let aExpr = aExpressions[aIndex];

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

@@ -47,15 +47,11 @@ export interface IKeybindingRule2 {
 	linux?: { primary: Keybinding | null; } | null;
 	mac?: { primary: Keybinding | null; } | null;
 	id: string;
+	args?: any;
 	weight: number;
 	when: ContextKeyExpr | null;
 }
 
-export const enum KeybindingRuleSource {
-	Core = 0,
-	Extension = 1
-}
-
 export const enum KeybindingWeight {
 	EditorCore = 0,
 	EditorContrib = 100,
@@ -70,20 +66,22 @@ export interface ICommandAndKeybindingRule extends IKeybindingRule {
 }
 
 export interface IKeybindingsRegistry {
-	registerKeybindingRule(rule: IKeybindingRule, source?: KeybindingRuleSource): void;
-	registerKeybindingRule2(rule: IKeybindingRule2, source?: KeybindingRuleSource): void;
-	registerCommandAndKeybindingRule(desc: ICommandAndKeybindingRule, source?: KeybindingRuleSource): void;
+	registerKeybindingRule(rule: IKeybindingRule): void;
+	setExtensionKeybindings(rules: IKeybindingRule2[]): void;
+	registerCommandAndKeybindingRule(desc: ICommandAndKeybindingRule): void;
 	getDefaultKeybindings(): IKeybindingItem[];
 }
 
 class KeybindingsRegistryImpl implements IKeybindingsRegistry {
 
-	private _keybindings: IKeybindingItem[];
-	private _keybindingsSorted: boolean;
+	private _coreKeybindings: IKeybindingItem[];
+	private _extensionKeybindings: IKeybindingItem[];
+	private _cachedMergedKeybindings: IKeybindingItem[] | null;
 
 	constructor() {
-		this._keybindings = [];
-		this._keybindingsSorted = true;
+		this._coreKeybindings = [];
+		this._extensionKeybindings = [];
+		this._cachedMergedKeybindings = null;
 	}
 
 	/**
@@ -128,13 +126,13 @@ class KeybindingsRegistryImpl implements IKeybindingsRegistry {
 		return kb;
 	}
 
-	public registerKeybindingRule(rule: IKeybindingRule, source: KeybindingRuleSource = KeybindingRuleSource.Core): void {
-		let actualKb = KeybindingsRegistryImpl.bindToCurrentPlatform(rule);
+	public registerKeybindingRule(rule: IKeybindingRule): void {
+		const actualKb = KeybindingsRegistryImpl.bindToCurrentPlatform(rule);
 
 		if (actualKb && actualKb.primary) {
 			const kk = createKeybinding(actualKb.primary, OS);
 			if (kk) {
-				this._registerDefaultKeybinding(kk, rule.id, rule.weight, 0, rule.when, source);
+				this._registerDefaultKeybinding(kk, rule.id, undefined, rule.weight, 0, rule.when);
 			}
 		}
 
@@ -143,22 +141,36 @@ class KeybindingsRegistryImpl implements IKeybindingsRegistry {
 				const k = actualKb.secondary[i];
 				const kk = createKeybinding(k, OS);
 				if (kk) {
-					this._registerDefaultKeybinding(kk, rule.id, rule.weight, -i - 1, rule.when, source);
+					this._registerDefaultKeybinding(kk, rule.id, undefined, rule.weight, -i - 1, rule.when);
 				}
 			}
 		}
 	}
 
-	public registerKeybindingRule2(rule: IKeybindingRule2, source: KeybindingRuleSource = KeybindingRuleSource.Core): void {
-		let actualKb = KeybindingsRegistryImpl.bindToCurrentPlatform2(rule);
+	public setExtensionKeybindings(rules: IKeybindingRule2[]): void {
+		let result: IKeybindingItem[] = [], keybindingsLen = 0;
+		for (let i = 0, len = rules.length; i < len; i++) {
+			const rule = rules[i];
+			let actualKb = KeybindingsRegistryImpl.bindToCurrentPlatform2(rule);
 
-		if (actualKb && actualKb.primary) {
-			this._registerDefaultKeybinding(actualKb.primary, rule.id, rule.weight, 0, rule.when, source);
+			if (actualKb && actualKb.primary) {
+				result[keybindingsLen++] = {
+					keybinding: actualKb.primary,
+					command: rule.id,
+					commandArgs: rule.args,
+					when: rule.when,
+					weight1: rule.weight,
+					weight2: 0
+				};
+			}
 		}
+
+		this._extensionKeybindings = result;
+		this._cachedMergedKeybindings = null;
 	}
 
-	public registerCommandAndKeybindingRule(desc: ICommandAndKeybindingRule, source: KeybindingRuleSource = KeybindingRuleSource.Core): void {
-		this.registerKeybindingRule(desc, source);
+	public registerCommandAndKeybindingRule(desc: ICommandAndKeybindingRule): void {
+		this.registerKeybindingRule(desc);
 		CommandsRegistry.registerCommand(desc);
 	}
 
@@ -196,31 +208,31 @@ class KeybindingsRegistryImpl implements IKeybindingsRegistry {
 		}
 	}
 
-	private _registerDefaultKeybinding(keybinding: Keybinding, commandId: string, weight1: number, weight2: number, when: ContextKeyExpr | null | undefined, source: KeybindingRuleSource): void {
-		if (source === KeybindingRuleSource.Core && OS === OperatingSystem.Windows) {
+	private _registerDefaultKeybinding(keybinding: Keybinding, commandId: string, commandArgs: any, weight1: number, weight2: number, when: ContextKeyExpr | null | undefined): void {
+		if (OS === OperatingSystem.Windows) {
 			if (keybinding.type === KeybindingType.Chord) {
 				this._assertNoCtrlAlt(keybinding.firstPart, commandId);
 			} else {
 				this._assertNoCtrlAlt(keybinding, commandId);
 			}
 		}
-		this._keybindings.push({
+		this._coreKeybindings.push({
 			keybinding: keybinding,
 			command: commandId,
-			commandArgs: undefined,
+			commandArgs: commandArgs,
 			when: when,
 			weight1: weight1,
 			weight2: weight2
 		});
-		this._keybindingsSorted = false;
+		this._cachedMergedKeybindings = null;
 	}
 
 	public getDefaultKeybindings(): IKeybindingItem[] {
-		if (!this._keybindingsSorted) {
-			this._keybindings.sort(sorter);
-			this._keybindingsSorted = true;
+		if (!this._cachedMergedKeybindings) {
+			this._cachedMergedKeybindings = (<IKeybindingItem[]>[]).concat(this._coreKeybindings).concat(this._extensionKeybindings);
+			this._cachedMergedKeybindings.sort(sorter);
 		}
-		return this._keybindings.slice(0);
+		return this._cachedMergedKeybindings.slice(0);
 	}
 }
 export const KeybindingsRegistry: IKeybindingsRegistry = new KeybindingsRegistryImpl();

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

@@ -77,15 +77,15 @@ suite('AbstractKeybindingService', () => {
 				altKey: keybinding.altKey,
 				metaKey: keybinding.metaKey,
 				keyCode: keybinding.keyCode,
-				code: null
-			}, null);
+				code: null!
+			}, null!);
 		}
 	}
 
-	let createTestKeybindingService: (items: ResolvedKeybindingItem[], contextValue?: any) => TestKeybindingService = null;
+	let createTestKeybindingService: (items: ResolvedKeybindingItem[], contextValue?: any) => TestKeybindingService = null!;
 	let currentContextValue: IContext | null = null;
-	let executeCommandCalls: { commandId: string; args: any[]; }[] = null;
-	let showMessageCalls: { sev: Severity, message: any; }[] = null;
+	let executeCommandCalls: { commandId: string; args: any[]; }[] = null!;
+	let showMessageCalls: { sev: Severity, message: any; }[] = null!;
 	let statusMessageCalls: string[] | null = null;
 	let statusMessageCallsDisposed: string[] | null = null;
 
@@ -99,12 +99,12 @@ suite('AbstractKeybindingService', () => {
 
 			let contextKeyService: IContextKeyService = {
 				_serviceBrand: undefined,
-				dispose: undefined,
-				onDidChangeContext: undefined,
-				createKey: undefined,
-				contextMatchesRules: undefined,
-				getContextKeyValue: undefined,
-				createScoped: undefined,
+				dispose: undefined!,
+				onDidChangeContext: undefined!,
+				createKey: undefined!,
+				contextMatchesRules: undefined!,
+				getContextKeyValue: undefined!,
+				createScoped: undefined!,
 				getContext: (target: IContextKeyServiceTarget): any => {
 					return currentContextValue;
 				}
@@ -118,7 +118,7 @@ suite('AbstractKeybindingService', () => {
 						commandId: commandId,
 						args: args
 					});
-					return Promise.resolve(void 0);
+					return Promise.resolve(undefined);
 				}
 			};
 
@@ -147,12 +147,12 @@ suite('AbstractKeybindingService', () => {
 
 			let statusbarService: IStatusbarService = {
 				_serviceBrand: undefined,
-				addEntry: undefined,
+				addEntry: undefined!,
 				setStatusMessage: (message: string, autoDisposeAfter?: number, delayBy?: number): IDisposable => {
-					statusMessageCalls.push(message);
+					statusMessageCalls!.push(message);
 					return {
 						dispose: () => {
-							statusMessageCallsDisposed.push(message);
+							statusMessageCallsDisposed!.push(message);
 						}
 					};
 				}
@@ -166,15 +166,15 @@ suite('AbstractKeybindingService', () => {
 
 	teardown(() => {
 		currentContextValue = null;
-		executeCommandCalls = null;
-		showMessageCalls = null;
-		createTestKeybindingService = null;
+		executeCommandCalls = null!;
+		showMessageCalls = null!;
+		createTestKeybindingService = null!;
 		statusMessageCalls = null;
 		statusMessageCallsDisposed = null;
 	});
 
 	function kbItem(keybinding: number, command: string, when: ContextKeyExpr | null = null): ResolvedKeybindingItem {
-		const resolvedKeybinding = (keybinding !== 0 ? new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS), OS) : null);
+		const resolvedKeybinding = (keybinding !== 0 ? new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS)!, OS) : null);
 		return new ResolvedKeybindingItem(
 			resolvedKeybinding,
 			command,
@@ -185,8 +185,8 @@ suite('AbstractKeybindingService', () => {
 	}
 
 	function toUsLabel(keybinding: number): string {
-		const usResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS), OS);
-		return usResolvedKeybinding.getLabel();
+		const usResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS)!, OS);
+		return usResolvedKeybinding.getLabel()!;
 	}
 
 	test('issue #16498: chord mode is quit for invalid chords', () => {

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

@@ -10,7 +10,7 @@ import { USLayoutResolvedKeybinding } from 'vs/platform/keybinding/common/usLayo
 suite('KeybindingLabels', () => {
 
 	function assertUSLabel(OS: OperatingSystem, keybinding: number, expected: string): void {
-		const usResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS), OS);
+		const usResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS)!, OS);
 		assert.equal(usResolvedKeybinding.getLabel(), expected);
 	}
 
@@ -115,7 +115,7 @@ suite('KeybindingLabels', () => {
 
 	test('Aria label', () => {
 		function assertAriaLabel(OS: OperatingSystem, keybinding: number, expected: string): void {
-			const usResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS), OS);
+			const usResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS)!, OS);
 			assert.equal(usResolvedKeybinding.getAriaLabel(), expected);
 		}
 
@@ -125,8 +125,8 @@ suite('KeybindingLabels', () => {
 	});
 
 	test('Electron Accelerator label', () => {
-		function assertElectronAcceleratorLabel(OS: OperatingSystem, keybinding: number, expected: string): void {
-			const usResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS), OS);
+		function assertElectronAcceleratorLabel(OS: OperatingSystem, keybinding: number, expected: string | null): void {
+			const usResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS)!, OS);
 			assert.equal(usResolvedKeybinding.getElectronAccelerator(), expected);
 		}
 
@@ -153,7 +153,7 @@ suite('KeybindingLabels', () => {
 
 	test('User Settings label', () => {
 		function assertElectronAcceleratorLabel(OS: OperatingSystem, keybinding: number, expected: string): void {
-			const usResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS), OS);
+			const usResolvedKeybinding = new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS)!, OS);
 			assert.equal(usResolvedKeybinding.getUserSettingsLabel(), expected);
 		}
 

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

@@ -21,7 +21,7 @@ function createContext(ctx: any) {
 suite('KeybindingResolver', () => {
 
 	function kbItem(keybinding: number, command: string, commandArgs: any, when: ContextKeyExpr, isDefault: boolean): ResolvedKeybindingItem {
-		const resolvedKeybinding = (keybinding !== 0 ? new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS), OS) : null);
+		const resolvedKeybinding = (keybinding !== 0 ? new USLayoutResolvedKeybinding(createKeybinding(keybinding, OS)!, OS) : null);
 		return new ResolvedKeybindingItem(
 			resolvedKeybinding,
 			command,
@@ -32,7 +32,7 @@ suite('KeybindingResolver', () => {
 	}
 
 	function getDispatchStr(runtimeKb: SimpleKeybinding): string {
-		return USLayoutResolvedKeybinding.getDispatchStr(runtimeKb);
+		return USLayoutResolvedKeybinding.getDispatchStr(runtimeKb)!;
 	}
 
 	test('resolve key', function () {
@@ -45,7 +45,7 @@ suite('KeybindingResolver', () => {
 		assert.equal(KeybindingResolver.contextMatchesRules(createContext({ bar: 'bz' }), contextRules), false);
 
 		let resolver = new KeybindingResolver([keybindingItem], []);
-		assert.equal(resolver.resolve(createContext({ bar: 'baz' }), null, getDispatchStr(<SimpleKeybinding>runtimeKeybinding)).commandId, 'yes');
+		assert.equal(resolver.resolve(createContext({ bar: 'baz' }), null, getDispatchStr(<SimpleKeybinding>runtimeKeybinding))!.commandId, 'yes');
 		assert.equal(resolver.resolve(createContext({ bar: 'bz' }), null, getDispatchStr(<SimpleKeybinding>runtimeKeybinding)), null);
 	});
 
@@ -57,7 +57,7 @@ suite('KeybindingResolver', () => {
 		let keybindingItem = kbItem(keybinding, 'yes', commandArgs, contextRules, true);
 
 		let resolver = new KeybindingResolver([keybindingItem], []);
-		assert.equal(resolver.resolve(createContext({ bar: 'baz' }), null, getDispatchStr(<SimpleKeybinding>runtimeKeybinding)).commandArgs, commandArgs);
+		assert.equal(resolver.resolve(createContext({ bar: 'baz' }), null, getDispatchStr(<SimpleKeybinding>runtimeKeybinding))!.commandArgs, commandArgs);
 	});
 
 	test('KeybindingResolver.combine simple 1', function () {
@@ -154,7 +154,7 @@ suite('KeybindingResolver', () => {
 			kbItem(KeyCode.KEY_B, 'yes2', null, ContextKeyExpr.equals('2', 'b'), true)
 		];
 		let overrides = [
-			kbItem(KeyCode.KEY_A, '-yes1', null, null, false)
+			kbItem(KeyCode.KEY_A, '-yes1', null, null!, false)
 		];
 		let actual = KeybindingResolver.combine(defaults, overrides);
 		assert.deepEqual(actual, [
@@ -168,7 +168,7 @@ suite('KeybindingResolver', () => {
 			kbItem(KeyCode.KEY_B, 'yes2', null, ContextKeyExpr.equals('2', 'b'), true)
 		];
 		let overrides = [
-			kbItem(0, '-yes1', null, null, false)
+			kbItem(0, '-yes1', null, null!, false)
 		];
 		let actual = KeybindingResolver.combine(defaults, overrides);
 		assert.deepEqual(actual, [
@@ -182,7 +182,7 @@ suite('KeybindingResolver', () => {
 			kbItem(KeyCode.KEY_B, 'yes2', null, ContextKeyExpr.equals('2', 'b'), true)
 		];
 		let overrides = [
-			kbItem(KeyCode.KEY_A, '-yes1', null, null, false)
+			kbItem(KeyCode.KEY_A, '-yes1', null, null!, false)
 		];
 		let actual = KeybindingResolver.combine(defaults, overrides);
 		assert.deepEqual(actual, [
@@ -210,7 +210,7 @@ suite('KeybindingResolver', () => {
 		let key3IsTrue = ContextKeyExpr.equals('key3', true);
 		let key4IsTrue = ContextKeyExpr.equals('key4', true);
 
-		assertIsIncluded([key1IsTrue], null);
+		assertIsIncluded([key1IsTrue], null!);
 		assertIsIncluded([key1IsTrue], []);
 		assertIsIncluded([key1IsTrue], [key1IsTrue]);
 		assertIsIncluded([key1IsTrue], [key1IsNotFalse]);
@@ -243,7 +243,7 @@ suite('KeybindingResolver', () => {
 		assertIsNotIncluded([key1IsTrue, key2IsNotFalse], [key4IsTrue]);
 		assertIsNotIncluded([key1IsTrue], [key2IsTrue]);
 		assertIsNotIncluded([], [key2IsTrue]);
-		assertIsNotIncluded(null, [key2IsTrue]);
+		assertIsNotIncluded(null!, [key2IsTrue]);
 	});
 
 	test('resolve command', function () {
@@ -272,7 +272,7 @@ suite('KeybindingResolver', () => {
 			_kbItem(
 				KeyCode.KEY_Z,
 				'second',
-				null
+				null!
 			),
 			// This one sometimes overwrites first
 			_kbItem(
@@ -290,43 +290,43 @@ suite('KeybindingResolver', () => {
 			_kbItem(
 				KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_Y, KeyCode.KEY_Z),
 				'fifth',
-				null
+				null!
 			),
 			// This one has no keybinding
 			_kbItem(
 				0,
 				'sixth',
-				null
+				null!
 			),
 			_kbItem(
 				KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.KEY_U),
 				'seventh',
-				null
+				null!
 			),
 			_kbItem(
 				KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.KEY_K),
 				'seventh',
-				null
+				null!
 			),
 			_kbItem(
 				KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.KEY_U),
 				'uncomment lines',
-				null
+				null!
 			),
 			_kbItem(
 				KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_K, KeyMod.CtrlCmd | KeyCode.KEY_C),
 				'comment lines',
-				null
+				null!
 			),
 			_kbItem(
 				KeyChord(KeyMod.CtrlCmd | KeyCode.KEY_G, KeyMod.CtrlCmd | KeyCode.KEY_C),
 				'unreachablechord',
-				null
+				null!
 			),
 			_kbItem(
 				KeyMod.CtrlCmd | KeyCode.KEY_G,
 				'eleven',
-				null
+				null!
 			)
 		];
 
@@ -337,30 +337,30 @@ suite('KeybindingResolver', () => {
 			let lookupResult = resolver.lookupKeybindings(commandId);
 			assert.equal(lookupResult.length, expectedKeys.length, 'Length mismatch @ commandId ' + commandId + '; GOT: ' + JSON.stringify(lookupResult, null, '\t'));
 			for (let i = 0, len = lookupResult.length; i < len; i++) {
-				const expected = new USLayoutResolvedKeybinding(createKeybinding(expectedKeys[i], OS), OS);
+				const expected = new USLayoutResolvedKeybinding(createKeybinding(expectedKeys[i], OS)!, OS);
 
-				assert.equal(lookupResult[i].resolvedKeybinding.getUserSettingsLabel(), expected.getUserSettingsLabel(), 'value mismatch @ commandId ' + commandId);
+				assert.equal(lookupResult[i].resolvedKeybinding!.getUserSettingsLabel(), expected.getUserSettingsLabel(), 'value mismatch @ commandId ' + commandId);
 			}
 		};
 
 		let testResolve = (ctx: IContext, _expectedKey: number, commandId: string) => {
-			const expectedKey = createKeybinding(_expectedKey, OS);
+			const expectedKey = createKeybinding(_expectedKey, OS)!;
 
 			if (expectedKey.type === KeybindingType.Chord) {
 				let firstPart = getDispatchStr(expectedKey.firstPart);
 				let chordPart = getDispatchStr(expectedKey.chordPart);
 
-				let result = resolver.resolve(ctx, null, firstPart);
+				let result = resolver.resolve(ctx, null, firstPart)!;
 				assert.ok(result !== null, 'Enters chord for ' + commandId);
 				assert.equal(result.commandId, null, 'Enters chord for ' + commandId);
 				assert.equal(result.enterChord, true, 'Enters chord for ' + commandId);
 
-				result = resolver.resolve(ctx, firstPart, chordPart);
+				result = resolver.resolve(ctx, firstPart, chordPart)!;
 				assert.ok(result !== null, 'Enters chord for ' + commandId);
 				assert.equal(result.commandId, commandId, 'Finds chorded command ' + commandId);
 				assert.equal(result.enterChord, false, 'Finds chorded command ' + commandId);
 			} else {
-				let result = resolver.resolve(ctx, null, getDispatchStr(expectedKey));
+				let result = resolver.resolve(ctx, null, getDispatchStr(expectedKey))!;
 				assert.ok(result !== null, 'Finds command ' + commandId);
 				assert.equal(result.commandId, commandId, 'Finds command ' + commandId);
 				assert.equal(result.enterChord, false, 'Finds command ' + commandId);

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

@@ -54,8 +54,9 @@ export class MockContextKeyService implements IContextKeyService {
 		return Event.None;
 	}
 	public getContextKeyValue(key: string) {
-		if (this._keys.has(key)) {
-			return this._keys.get(key).get();
+		const value = this._keys.get(key);
+		if (value) {
+			return value.get();
 		}
 	}
 	public getContext(domNode: HTMLElement): any {
@@ -108,8 +109,8 @@ export class MockKeybindingService implements IKeybindingService {
 		return [];
 	}
 
-	public lookupKeybinding(commandId: string): ResolvedKeybinding | null {
-		return null;
+	public lookupKeybinding(commandId: string): ResolvedKeybinding | undefined {
+		return undefined;
 	}
 
 	public customKeybindingsCount(): number {
@@ -120,11 +121,15 @@ export class MockKeybindingService implements IKeybindingService {
 		return null;
 	}
 
-	dispatchEvent(e: IKeyboardEvent, target: IContextKeyServiceTarget): boolean {
+	public dispatchByUserSettingsLabel(userSettingsLabel: string, target: IContextKeyServiceTarget): void {
+
+	}
+
+	public dispatchEvent(e: IKeyboardEvent, target: IContextKeyServiceTarget): boolean {
 		return false;
 	}
 
-	mightProducePrintableCharacter(e: IKeyboardEvent): boolean {
+	public mightProducePrintableCharacter(e: IKeyboardEvent): boolean {
 		return false;
 	}
 }