Merge from vscode 7653d836944892f83ce9e1f95c1204bafa1aec31

2026-02-16 10:58:30 -05:00 · 2020-05-08 03:58:34 +00:00
parent dac1970c43
commit fa62ec1f34
209 changed files with 5131 additions and 2480 deletions
--- a/src/vs/base/browser/ui/actionbar/actionbar.ts
+++ b/src/vs/base/browser/ui/actionbar/actionbar.ts
@@ -477,27 +477,27 @@ export class ActionBar extends Disposable implements IActionRunner {
 			DOM.addClass(this.domNode, 'animated');
 		}

-		let previousKey: KeyCode;
-		let nextKey: KeyCode;
+		let previousKeys: KeyCode[];
+		let nextKeys: KeyCode[];

 		switch (this.options.orientation) {
 			case ActionsOrientation.HORIZONTAL:
-				previousKey = KeyCode.LeftArrow;
-				nextKey = KeyCode.RightArrow;
+				previousKeys = [KeyCode.LeftArrow, KeyCode.UpArrow];
+				nextKeys = [KeyCode.RightArrow, KeyCode.DownArrow];
 				break;
 			case ActionsOrientation.HORIZONTAL_REVERSE:
-				previousKey = KeyCode.RightArrow;
-				nextKey = KeyCode.LeftArrow;
+				previousKeys = [KeyCode.RightArrow, KeyCode.DownArrow];
+				nextKeys = [KeyCode.LeftArrow, KeyCode.UpArrow];
 				this.domNode.className += ' reverse';
 				break;
 			case ActionsOrientation.VERTICAL:
-				previousKey = KeyCode.UpArrow;
-				nextKey = KeyCode.DownArrow;
+				previousKeys = [KeyCode.LeftArrow, KeyCode.UpArrow];
+				nextKeys = [KeyCode.RightArrow, KeyCode.DownArrow];
 				this.domNode.className += ' vertical';
 				break;
 			case ActionsOrientation.VERTICAL_REVERSE:
-				previousKey = KeyCode.DownArrow;
-				nextKey = KeyCode.UpArrow;
+				previousKeys = [KeyCode.RightArrow, KeyCode.DownArrow];
+				nextKeys = [KeyCode.LeftArrow, KeyCode.UpArrow];
 				this.domNode.className += ' vertical reverse';
 				break;
 		}
@@ -506,9 +506,9 @@ export class ActionBar extends Disposable implements IActionRunner {
 			const event = new StandardKeyboardEvent(e);
 			let eventHandled = true;

-			if (event.equals(previousKey)) {
+			if (previousKeys && (event.equals(previousKeys[0]) || event.equals(previousKeys[1]))) {
 				this.focusPrevious();
-			} else if (event.equals(nextKey)) {
+			} else if (nextKeys && (event.equals(nextKeys[0]) || event.equals(nextKeys[1]))) {
 				this.focusNext();
 			} else if (event.equals(KeyCode.Escape)) {
 				this._onDidCancel.fire();
--- a/src/vs/base/browser/ui/countBadge/countBadge.css
+++ b/src/vs/base/browser/ui/countBadge/countBadge.css
@@ -4,7 +4,7 @@
 *--------------------------------------------------------------------------------------------*/

 .monaco-count-badge {
-	padding: 3px 5px;
+	padding: 3px 6px;
 	border-radius: 11px;
 	font-size: 11px;
 	min-width: 18px;
@@ -14,4 +14,9 @@
 	text-align: center;
 	display: inline-block;
 	box-sizing: border-box;
-}
+}
+
+.monaco-count-badge.long {
+	padding: 2px 3px;
+	border-radius: 2px;
+}
--- a/src/vs/base/browser/ui/tree/indexTreeModel.ts
+++ b/src/vs/base/browser/ui/tree/indexTreeModel.ts
@@ -18,6 +18,7 @@ export interface IIndexTreeNode<T, TFilterData = void> extends ITreeNode<T, TFil
 	collapsible: boolean;
 	collapsed: boolean;
 	renderNodeCount: number;
+	visibility: TreeVisibility;
 	visible: boolean;
 	filterData: TFilterData | undefined;
 }
@@ -95,6 +96,7 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
 			collapsible: false,
 			collapsed: false,
 			renderNodeCount: 0,
+			visibility: TreeVisibility.Visible,
 			visible: true,
 			filterData: undefined
 		};
@@ -185,6 +187,17 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
 		}

 		this._onDidSplice.fire({ insertedNodes: nodesToInsert, deletedNodes });
+
+		let node: IIndexTreeNode<T, TFilterData> | undefined = parentNode;
+
+		while (node) {
+			if (node.visibility === TreeVisibility.Recurse) {
+				this.refilter();
+				break;
+			}
+
+			node = node.parent;
+		}
 	}

 	rerender(location: number[]): void {
@@ -194,7 +207,7 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi

 		const { node, listIndex, revealed } = this.getTreeNodeWithListIndex(location);

-		if (revealed) {
+		if (node.visible && revealed) {
 			this.list.splice(listIndex, 1, [node]);
 		}
 	}
@@ -355,11 +368,13 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
 			collapsible: typeof treeElement.collapsible === 'boolean' ? treeElement.collapsible : (typeof treeElement.collapsed !== 'undefined'),
 			collapsed: typeof treeElement.collapsed === 'undefined' ? this.collapseByDefault : treeElement.collapsed,
 			renderNodeCount: 1,
+			visibility: TreeVisibility.Visible,
 			visible: true,
 			filterData: undefined
 		};

 		const visibility = this._filterNode(node, parentVisibility);
+		node.visibility = visibility;

 		if (revealed) {
 			treeListElements.push(node);
--- a/src/vs/base/common/codicons.ts
+++ b/src/vs/base/common/codicons.ts
@@ -43,12 +43,12 @@ const _registry = new Registry();

 export const iconRegistry: IIconRegistry = _registry;

-export function registerIcon(id: string, def: Codicon) {
+export function registerIcon(id: string, def: Codicon, description?: string) {
 	return new Codicon(id, def);
 }

 export class Codicon {
-	constructor(public readonly id: string, public readonly definition: Codicon | IconDefinition) {
+	constructor(public readonly id: string, public readonly definition: Codicon | IconDefinition, public description?: string) {
 		_registry.add(this);
 	}
 	public get classNames() { return 'codicon codicon-' + this.id; }
--- a/src/vs/base/common/jsonSchema.ts
+++ b/src/vs/base/common/jsonSchema.ts
@@ -63,6 +63,7 @@ export interface IJSONSchema {
 	markdownEnumDescriptions?: string[];
 	markdownDescription?: string;
 	doNotSuggest?: boolean;
+	suggestSortText?: string;
 	allowComments?: boolean;
 	allowTrailingCommas?: boolean;
 }
--- a/src/vs/base/common/map.ts
+++ b/src/vs/base/common/map.ts
@@ -580,9 +580,7 @@ export const enum Touch {
 	AsNew = 2
 }

-export class LinkedMap<K, V> implements Map<K, V>{
-
-	readonly [Symbol.toStringTag] = 'LinkedMap';
+export class LinkedMap<K, V> {

 	private _map: Map<K, Item<K, V>>;
 	private _head: Item<K, V> | undefined;
@@ -634,7 +632,7 @@ export class LinkedMap<K, V> implements Map<K, V>{
 		return item.value;
 	}

-	set(key: K, value: V, touch: Touch = Touch.None): this {
+	set(key: K, value: V, touch: Touch = Touch.None): void {
 		let item = this._map.get(key);
 		if (item) {
 			item.value = value;
@@ -660,7 +658,6 @@ export class LinkedMap<K, V> implements Map<K, V>{
 			this._map.set(key, item);
 			this._size++;
 		}
-		return this;
 	}

 	delete(key: K): boolean {
@@ -704,13 +701,34 @@ export class LinkedMap<K, V> implements Map<K, V>{
 		}
 	}

-	keys(): IterableIterator<K> {
+	values(): V[] {
+		const result: V[] = [];
 		let current = this._head;
+		while (current) {
+			result.push(current.value);
+			current = current.next;
+		}
+		return result;
+	}
+
+	keys(): K[] {
+		const result: K[] = [];
+		let current = this._head;
+		while (current) {
+			result.push(current.key);
+			current = current.next;
+		}
+		return result;
+	}
+
+	/* VS Code / Monaco editor runs on es5 which has no Symbol.iterator
+	keys(): IterableIterator<K> {
+		const current = this._head;
 		const iterator: IterableIterator<K> = {
 			[Symbol.iterator]() {
 				return iterator;
 			},
-			next(): IteratorResult<K> {
+			next():IteratorResult<K> {
 				if (current) {
 					const result = { value: current.key, done: false };
 					current = current.next;
@@ -724,12 +742,12 @@ export class LinkedMap<K, V> implements Map<K, V>{
 	}

 	values(): IterableIterator<V> {
-		let current = this._head;
+		const current = this._head;
 		const iterator: IterableIterator<V> = {
 			[Symbol.iterator]() {
 				return iterator;
 			},
-			next(): IteratorResult<V> {
+			next():IteratorResult<V> {
 				if (current) {
 					const result = { value: current.value, done: false };
 					current = current.next;
@@ -741,29 +759,7 @@ export class LinkedMap<K, V> implements Map<K, V>{
 		};
 		return iterator;
 	}
-
-	entries(): IterableIterator<[K, V]> {
-		let current = this._head;
-		const iterator: IterableIterator<[K, V]> = {
-			[Symbol.iterator]() {
-				return iterator;
-			},
-			next(): IteratorResult<[K, V]> {
-				if (current) {
-					const result: IteratorResult<[K, V]> = { value: [current.key, current.value], done: false };
-					current = current.next;
-					return result;
-				} else {
-					return { value: undefined, done: true };
-				}
-			}
-		};
-		return iterator;
-	}
-
-	[Symbol.iterator](): IterableIterator<[K, V]> {
-		return this.entries();
-	}
+	*/

 	protected trimOld(newSize: number) {
 		if (newSize >= this.size) {
@@ -965,10 +961,9 @@ export class LRUCache<K, V> extends LinkedMap<K, V> {
 		return super.get(key, Touch.None);
 	}

-	set(key: K, value: V): this {
+	set(key: K, value: V): void {
 		super.set(key, value, Touch.AsNew);
 		this.checkTrim();
-		return this;
 	}

 	private checkTrim() {
--- a/src/vs/base/parts/quickinput/browser/media/quickInput.css
+++ b/src/vs/base/parts/quickinput/browser/media/quickInput.css
@@ -97,10 +97,14 @@
 	align-self: center;
 	position: absolute;
 	right: 4px;
+	display: flex;
+	align-items: center;
 }

 .quick-input-count .monaco-count-badge {
 	vertical-align: middle;
+	padding: 2px 4px;
+	border-radius: 2px;
 }

 .quick-input-action {
@@ -108,9 +112,8 @@
 }

 .quick-input-action .monaco-text-button {
-	font-size: 85%;
+	font-size: 11px;
 	padding: 0 6px;
-	line-height: initial;
 	display: flex;
 	height: 100%;
 	align-items: center;
--- a/src/vs/base/test/browser/ui/tree/objectTreeModel.test.ts
+++ b/src/vs/base/test/browser/ui/tree/objectTreeModel.test.ts
@@ -4,13 +4,14 @@
 *--------------------------------------------------------------------------------------------*/

 import * as assert from 'assert';
-import { ITreeNode } from 'vs/base/browser/ui/tree/tree';
+import { ITreeNode, ITreeFilter, TreeVisibility } from 'vs/base/browser/ui/tree/tree';
 import { ISpliceable } from 'vs/base/common/sequence';
 import { ObjectTreeModel } from 'vs/base/browser/ui/tree/objectTreeModel';

 function toSpliceable<T>(arr: T[]): ISpliceable<T> {
 	return {
 		splice(start: number, deleteCount: number, elements: T[]): void {
+			// console.log(`splice (${start}, ${deleteCount}, ${elements.length} [${elements.join(', ')}] )`); // debugging
 			arr.splice(start, deleteCount, ...elements);
 		}
 	};
@@ -240,4 +241,35 @@ suite('ObjectTreeModel', function () {
 		model.expandTo(1000);
 		assert.deepEqual(toArray(list), [0, 10, 100, 1000, 11, 12, 1, 2]);
 	});
+
+	test('issue #95641', () => {
+		const list: ITreeNode<string>[] = [];
+		let fn = (_: string) => true;
+		const filter = new class implements ITreeFilter<string> {
+			filter(element: string, parentVisibility: TreeVisibility): TreeVisibility {
+				if (element === 'file') {
+					return TreeVisibility.Recurse;
+				}
+
+				return fn(element) ? TreeVisibility.Visible : parentVisibility;
+			}
+		};
+		const model = new ObjectTreeModel<string>('test', toSpliceable(list), { filter });
+
+		model.setChildren(null, [{ element: 'file', children: [{ element: 'hello' }] }]);
+		assert.deepEqual(toArray(list), ['file', 'hello']);
+
+		fn = (el: string) => el === 'world';
+		model.refilter();
+		assert.deepEqual(toArray(list), []);
+
+		model.setChildren('file', [{ element: 'world' }]);
+		assert.deepEqual(toArray(list), ['file', 'world']);
+
+		model.setChildren('file', [{ element: 'hello' }]);
+		assert.deepEqual(toArray(list), []);
+
+		model.setChildren('file', [{ element: 'world' }]);
+		assert.deepEqual(toArray(list), ['file', 'world']);
+	});
 });
--- a/src/vs/base/test/common/map.test.ts
+++ b/src/vs/base/test/common/map.test.ts
@@ -13,8 +13,8 @@ suite('Map', () => {
 		let map = new LinkedMap<string, string>();
 		map.set('ak', 'av');
 		map.set('bk', 'bv');
-		assert.deepStrictEqual([...map.keys()], ['ak', 'bk']);
-		assert.deepStrictEqual([...map.values()], ['av', 'bv']);
+		assert.deepStrictEqual(map.keys(), ['ak', 'bk']);
+		assert.deepStrictEqual(map.values(), ['av', 'bv']);
 		assert.equal(map.first, 'av');
 		assert.equal(map.last, 'bv');
 	});
@@ -23,16 +23,16 @@ suite('Map', () => {
 		let map = new LinkedMap<string, string>();
 		map.set('ak', 'av');
 		map.set('ak', 'av', Touch.AsOld);
-		assert.deepStrictEqual([...map.keys()], ['ak']);
-		assert.deepStrictEqual([...map.values()], ['av']);
+		assert.deepStrictEqual(map.keys(), ['ak']);
+		assert.deepStrictEqual(map.values(), ['av']);
 	});

 	test('LinkedMap - Touch New one', () => {
 		let map = new LinkedMap<string, string>();
 		map.set('ak', 'av');
 		map.set('ak', 'av', Touch.AsNew);
-		assert.deepStrictEqual([...map.keys()], ['ak']);
-		assert.deepStrictEqual([...map.values()], ['av']);
+		assert.deepStrictEqual(map.keys(), ['ak']);
+		assert.deepStrictEqual(map.values(), ['av']);
 	});

 	test('LinkedMap - Touch Old two', () => {
@@ -40,8 +40,8 @@ suite('Map', () => {
 		map.set('ak', 'av');
 		map.set('bk', 'bv');
 		map.set('bk', 'bv', Touch.AsOld);
-		assert.deepStrictEqual([...map.keys()], ['bk', 'ak']);
-		assert.deepStrictEqual([...map.values()], ['bv', 'av']);
+		assert.deepStrictEqual(map.keys(), ['bk', 'ak']);
+		assert.deepStrictEqual(map.values(), ['bv', 'av']);
 	});

 	test('LinkedMap - Touch New two', () => {
@@ -49,8 +49,8 @@ suite('Map', () => {
 		map.set('ak', 'av');
 		map.set('bk', 'bv');
 		map.set('ak', 'av', Touch.AsNew);
-		assert.deepStrictEqual([...map.keys()], ['bk', 'ak']);
-		assert.deepStrictEqual([...map.values()], ['bv', 'av']);
+		assert.deepStrictEqual(map.keys(), ['bk', 'ak']);
+		assert.deepStrictEqual(map.values(), ['bv', 'av']);
 	});

 	test('LinkedMap - Touch Old from middle', () => {
@@ -59,8 +59,8 @@ suite('Map', () => {
 		map.set('bk', 'bv');
 		map.set('ck', 'cv');
 		map.set('bk', 'bv', Touch.AsOld);
-		assert.deepStrictEqual([...map.keys()], ['bk', 'ak', 'ck']);
-		assert.deepStrictEqual([...map.values()], ['bv', 'av', 'cv']);
+		assert.deepStrictEqual(map.keys(), ['bk', 'ak', 'ck']);
+		assert.deepStrictEqual(map.values(), ['bv', 'av', 'cv']);
 	});

 	test('LinkedMap - Touch New from middle', () => {
@@ -69,8 +69,8 @@ suite('Map', () => {
 		map.set('bk', 'bv');
 		map.set('ck', 'cv');
 		map.set('bk', 'bv', Touch.AsNew);
-		assert.deepStrictEqual([...map.keys()], ['ak', 'ck', 'bk']);
-		assert.deepStrictEqual([...map.values()], ['av', 'cv', 'bv']);
+		assert.deepStrictEqual(map.keys(), ['ak', 'ck', 'bk']);
+		assert.deepStrictEqual(map.values(), ['av', 'cv', 'bv']);
 	});

 	test('LinkedMap - basics', function () {
@@ -136,15 +136,13 @@ suite('Map', () => {
 		assert.strictEqual(cache.size, 5);
 		cache.set(6, 6);
 		assert.strictEqual(cache.size, 5);
-		assert.deepStrictEqual([...cache.keys()], [2, 3, 4, 5, 6]);
+		assert.deepStrictEqual(cache.keys(), [2, 3, 4, 5, 6]);
 		cache.set(7, 7);
 		assert.strictEqual(cache.size, 5);
-		assert.deepStrictEqual([...cache.keys()], [3, 4, 5, 6, 7]);
+		assert.deepStrictEqual(cache.keys(), [3, 4, 5, 6, 7]);
 		let values: number[] = [];
 		[3, 4, 5, 6, 7].forEach(key => values.push(cache.get(key)!));
 		assert.deepStrictEqual(values, [3, 4, 5, 6, 7]);
-
-		assert.deepEqual([...cache.entries()], [[3, 3], [4, 4], [5, 5], [6, 6], [7, 7]]);
 	});

 	test('LinkedMap - LRU Cache get', () => {
@@ -152,11 +150,11 @@ suite('Map', () => {

 		[1, 2, 3, 4, 5].forEach(value => cache.set(value, value));
 		assert.strictEqual(cache.size, 5);
-		assert.deepStrictEqual([...cache.keys()], [1, 2, 3, 4, 5]);
+		assert.deepStrictEqual(cache.keys(), [1, 2, 3, 4, 5]);
 		cache.get(3);
-		assert.deepStrictEqual([...cache.keys()], [1, 2, 4, 5, 3]);
+		assert.deepStrictEqual(cache.keys(), [1, 2, 4, 5, 3]);
 		cache.peek(4);
-		assert.deepStrictEqual([...cache.keys()], [1, 2, 4, 5, 3]);
+		assert.deepStrictEqual(cache.keys(), [1, 2, 4, 5, 3]);
 		let values: number[] = [];
 		[1, 2, 3, 4, 5].forEach(key => values.push(cache.get(key)!));
 		assert.deepStrictEqual(values, [1, 2, 3, 4, 5]);
@@ -171,7 +169,7 @@ suite('Map', () => {
 		assert.strictEqual(cache.size, 10);
 		cache.limit = 5;
 		assert.strictEqual(cache.size, 5);
-		assert.deepStrictEqual([...cache.keys()], [6, 7, 8, 9, 10]);
+		assert.deepStrictEqual(cache.keys(), [6, 7, 8, 9, 10]);
 		cache.limit = 20;
 		assert.strictEqual(cache.size, 5);
 		for (let i = 11; i <= 20; i++) {
@@ -183,7 +181,7 @@ suite('Map', () => {
 			values.push(cache.get(i)!);
 			assert.strictEqual(cache.get(i), i);
 		}
-		assert.deepStrictEqual([...cache.values()], values);
+		assert.deepStrictEqual(cache.values(), values);
 	});

 	test('LinkedMap - LRU Cache limit with ratio', () => {
@@ -195,11 +193,11 @@ suite('Map', () => {
 		assert.strictEqual(cache.size, 10);
 		cache.set(11, 11);
 		assert.strictEqual(cache.size, 5);
-		assert.deepStrictEqual([...cache.keys()], [7, 8, 9, 10, 11]);
+		assert.deepStrictEqual(cache.keys(), [7, 8, 9, 10, 11]);
 		let values: number[] = [];
-		[...cache.keys()].forEach(key => values.push(cache.get(key)!));
+		cache.keys().forEach(key => values.push(cache.get(key)!));
 		assert.deepStrictEqual(values, [7, 8, 9, 10, 11]);
-		assert.deepStrictEqual([...cache.values()], values);
+		assert.deepStrictEqual(cache.values(), values);
 	});

 	test('LinkedMap - toJSON / fromJSON', () => {
@@ -239,7 +237,7 @@ suite('Map', () => {
 		map.delete('1');
 		assert.equal(map.get('1'), undefined);
 		assert.equal(map.size, 0);
-		assert.equal([...map.keys()].length, 0);
+		assert.equal(map.keys().length, 0);
 	});

 	test('LinkedMap - delete Head', function () {
@@ -253,8 +251,8 @@ suite('Map', () => {
 		map.delete('1');
 		assert.equal(map.get('2'), 2);
 		assert.equal(map.size, 1);
-		assert.equal([...map.keys()].length, 1);
-		assert.equal([...map.keys()][0], 2);
+		assert.equal(map.keys().length, 1);
+		assert.equal(map.keys()[0], 2);
 	});

 	test('LinkedMap - delete Tail', function () {
@@ -268,8 +266,8 @@ suite('Map', () => {
 		map.delete('2');
 		assert.equal(map.get('1'), 1);
 		assert.equal(map.size, 1);
-		assert.equal([...map.keys()].length, 1);
-		assert.equal([...map.keys()][0], 1);
+		assert.equal(map.keys().length, 1);
+		assert.equal(map.keys()[0], 1);
 	});