Don't pass on CKS change events from parent, when all changed keys are overridden by the child scoped CKS (microsoft#152775)

Fixes microsoft#125109

Author: roblourens

src/vs/platform/contextkey/browser/contextKeyService.ts

@@ -22,7 +22,7 @@ const KEYBINDING_CONTEXT_ATTR = 'data-keybinding-context';
 export class Context implements IContext {
 
 	protected _parent: Context | null;
-	protected _value: { [key: string]: any };
+	protected _value: Record<string, any>;
 	protected _id: number;
 
 	constructor(id: number, parent: Context | null) {
@@ -32,6 +32,10 @@ export class Context implements IContext {
 		this._value['_contextId'] = id;
 	}
 
+	public get value(): Record<string, any> {
+		return { ...this._value };
+	}
+
 	public setValue(key: string, value: any): boolean {
 		// console.log('SET ' + key + ' = ' + value + ' ON ' + this._id);
 		if (this._value[key] !== value) {
@@ -62,7 +66,7 @@ export class Context implements IContext {
 		this._parent = parent;
 	}
 
-	public collectAllValues(): { [key: string]: any } {
+	public collectAllValues(): Record<string, any> {
 		let result = this._parent ? this._parent.collectAllValues() : Object.create(null);
 		result = { ...result, ...this._value };
 		delete result['_contextId'];
@@ -247,6 +251,12 @@ class CompositeContextKeyChangeEvent implements IContextKeyChangeEvent {
 	}
 }
 
+function allEventKeysInContext(event: IContextKeyChangeEvent, context: Record<string, any>): boolean {
+	return (event instanceof ArrayContextKeyChangeEvent && event.keys.every(key => key in context)) ||
+		(event instanceof SimpleContextKeyChangeEvent && event.key in context) ||
+		(event instanceof CompositeContextKeyChangeEvent && event.events.every(e => allEventKeysInContext(e, context)));
+}
+
 export abstract class AbstractContextKeyService implements IContextKeyService {
 	declare _serviceBrand: undefined;
 
@@ -439,7 +449,14 @@ class ScopedContextKeyService extends AbstractContextKeyService {
 
 	private _updateParentChangeListener(): void {
 		// Forward parent events to this listener. Parent will change.
-		this._parentChangeListener.value = this._parent.onDidChangeContext(this._onDidChangeContext.fire, this._onDidChangeContext);
+		this._parentChangeListener.value = this._parent.onDidChangeContext(e => {
+			const thisContainer = this._parent.getContextValuesContainer(this._myContextId);
+			const thisContextValues = thisContainer.value;
+
+			if (!allEventKeysInContext(e, thisContextValues)) {
+				this._onDidChangeContext.fire(e);
+			}
+		});
 	}
 
 	public dispose(): void {

src/vs/platform/contextkey/test/browser/contextkey.test.ts

@@ -3,6 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 import * as assert from 'assert';
+import { DeferredPromise } from 'vs/base/common/async';
 import { DisposableStore } from 'vs/base/common/lifecycle';
 import { URI } from 'vs/base/common/uri';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
@@ -73,4 +74,77 @@ suite('ContextKeyService', () => {
 		const expr = ContextKeyExpr.in('notebookCellResource', 'jupyter.runByLineCells');
 		assert.deepStrictEqual(contextKeyService.contextMatchesRules(expr), true);
 	});
+
+	test('suppress update event from parent when one key is overridden by child', () => {
+		const root = new ContextKeyService(new TestConfigurationService());
+		const child = root.createScoped(document.createElement('div'));
+
+		root.createKey('testA', 1);
+		child.createKey('testA', 4);
+
+		let fired = false;
+		const event = child.onDidChangeContext(e => fired = true);
+		root.setContext('testA', 10);
+		assert.strictEqual(fired, false, 'Should not fire event when overridden key is updated in parent');
+		event.dispose();
+	});
+
+	test('suppress update event from parent when all keys are overridden by child', () => {
+		const root = new ContextKeyService(new TestConfigurationService());
+		const child = root.createScoped(document.createElement('div'));
+
+		root.createKey('testA', 1);
+		root.createKey('testB', 2);
+		root.createKey('testC', 3);
+
+		child.createKey('testA', 4);
+		child.createKey('testB', 5);
+		child.createKey('testD', 6);
+
+		let fired = false;
+		const event = child.onDidChangeContext(e => fired = true);
+		root.bufferChangeEvents(() => {
+			root.setContext('testA', 10);
+			root.setContext('testB', 20);
+			root.setContext('testD', 30);
+		});
+
+		assert.strictEqual(fired, false, 'Should not fire event when overridden key is updated in parent');
+		event.dispose();
+	});
+
+	test('pass through update event from parent when one key is not overridden by child', () => {
+		const root = new ContextKeyService(new TestConfigurationService());
+		const child = root.createScoped(document.createElement('div'));
+
+		root.createKey('testA', 1);
+		root.createKey('testB', 2);
+		root.createKey('testC', 3);
+
+		child.createKey('testA', 4);
+		child.createKey('testB', 5);
+		child.createKey('testD', 6);
+
+		const def = new DeferredPromise();
+		child.onDidChangeContext(e => {
+			try {
+				assert.ok(e.affectsSome(new Set(['testA'])), 'testA changed');
+				assert.ok(e.affectsSome(new Set(['testB'])), 'testB changed');
+				assert.ok(e.affectsSome(new Set(['testC'])), 'testC changed');
+			} catch (err) {
+				def.error(err);
+				return;
+			}
+
+			def.complete(undefined);
+		});
+
+		root.bufferChangeEvents(() => {
+			root.setContext('testA', 10);
+			root.setContext('testB', 20);
+			root.setContext('testC', 30);
+		});
+
+		return def.p;
+	});
 });