Merge from vscode 64980ea1f3f532c82bb6c28d27bba9ef2c5b4463 (#7206)

* Merge from vscode 64980ea1f3f532c82bb6c28d27bba9ef2c5b4463 * fix config changes * fix strictnull checks
2026-01-19 09:35:36 -05:00 · 2019-09-15 22:38:26 -07:00
parent fa6c52699e
commit ea0f9e6ce9
1226 changed files with 21541 additions and 17633 deletions
--- a/src/vs/base/browser/ui/tree/compressedObjectTreeModel.ts
+++ b/src/vs/base/browser/ui/tree/compressedObjectTreeModel.ts
@@ -6,19 +6,32 @@
 import { ISpliceable } from 'vs/base/common/sequence';
 import { Iterator, ISequence } from 'vs/base/common/iterator';
 import { Event } from 'vs/base/common/event';
-import { ITreeModel, ITreeNode, ITreeElement, ICollapseStateChangeEvent, ITreeModelSpliceEvent } from 'vs/base/browser/ui/tree/tree';
+import { ITreeModel, ITreeNode, ITreeElement, ICollapseStateChangeEvent, ITreeModelSpliceEvent, TreeError, TreeFilterResult, TreeVisibility, WeakMapper } from 'vs/base/browser/ui/tree/tree';
 import { IObjectTreeModelOptions, ObjectTreeModel, IObjectTreeModel } from 'vs/base/browser/ui/tree/objectTreeModel';

+// Exported only for test reasons, do not use directly
 export interface ICompressedTreeElement<T> extends ITreeElement<T> {
 	readonly children?: Iterator<ICompressedTreeElement<T>> | ICompressedTreeElement<T>[];
 	readonly incompressible?: boolean;
 }

+// Exported only for test reasons, do not use directly
 export interface ICompressedTreeNode<T> {
 	readonly elements: T[];
 	readonly incompressible: boolean;
 }

+function noCompress<T>(element: ICompressedTreeElement<T>): ITreeElement<ICompressedTreeNode<T>> {
+	const elements = [element.element];
+	const incompressible = element.incompressible || false;
+
+	return {
+		element: { elements, incompressible },
+		children: Iterator.map(Iterator.from(element.children), noCompress)
+	};
+}
+
+// Exported only for test reasons, do not use directly
 export function compress<T>(element: ICompressedTreeElement<T>): ITreeElement<ICompressedTreeNode<T>> {
 	const elements = [element.element];
 	const incompressible = element.incompressible || false;
@@ -49,7 +62,7 @@ export function compress<T>(element: ICompressedTreeElement<T>): ITreeElement<IC
 	};
 }

-export function _decompress<T>(element: ITreeElement<ICompressedTreeNode<T>>, index = 0): ICompressedTreeElement<T> {
+function _decompress<T>(element: ITreeElement<ICompressedTreeNode<T>>, index = 0): ICompressedTreeElement<T> {
 	let children: Iterator<ICompressedTreeElement<T>>;

 	if (index < element.element.elements.length - 1) {
@@ -65,11 +78,12 @@ export function _decompress<T>(element: ITreeElement<ICompressedTreeNode<T>>, in
 	return { element: element.element.elements[index], children };
 }

+// Exported only for test reasons, do not use directly
 export function decompress<T>(element: ITreeElement<ICompressedTreeNode<T>>): ICompressedTreeElement<T> {
 	return _decompress(element, 0);
 }

-export function splice<T>(treeElement: ICompressedTreeElement<T>, element: T, children: Iterator<ICompressedTreeElement<T>>): ICompressedTreeElement<T> {
+function splice<T>(treeElement: ICompressedTreeElement<T>, element: T, children: Iterator<ICompressedTreeElement<T>>): ICompressedTreeElement<T> {
 	if (treeElement.element === element) {
 		return { element, children };
 	}
@@ -80,9 +94,10 @@ export function splice<T>(treeElement: ICompressedTreeElement<T>, element: T, ch
 	};
 }

-export interface ICompressedTreeModelOptions<T, TFilterData> extends IObjectTreeModelOptions<ICompressedTreeNode<T>, TFilterData> { }
+interface ICompressedObjectTreeModelOptions<T, TFilterData> extends IObjectTreeModelOptions<ICompressedTreeNode<T>, TFilterData> { }

-export class CompressedTreeModel<T extends NonNullable<any>, TFilterData extends NonNullable<any> = void> implements ITreeModel<ICompressedTreeNode<T> | null, TFilterData, T | null> {
+// Exported only for test reasons, do not use directly
+export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData extends NonNullable<any> = void> implements ITreeModel<ICompressedTreeNode<T> | null, TFilterData, T | null> {

 	readonly rootRef = null;

@@ -92,35 +107,77 @@ export class CompressedTreeModel<T extends NonNullable<any>, TFilterData extends

 	private model: ObjectTreeModel<ICompressedTreeNode<T>, TFilterData>;
 	private nodes = new Map<T | null, ICompressedTreeNode<T>>();
+	private enabled: boolean = true;

 	get size(): number { return this.nodes.size; }

-	constructor(list: ISpliceable<ITreeNode<ICompressedTreeNode<T>, TFilterData>>, options: ICompressedTreeModelOptions<T, TFilterData> = {}) {
-		this.model = new ObjectTreeModel(list, options);
+	constructor(
+		private user: string,
+		list: ISpliceable<ITreeNode<ICompressedTreeNode<T>, TFilterData>>,
+		options: ICompressedObjectTreeModelOptions<T, TFilterData> = {}
+	) {
+		this.model = new ObjectTreeModel(user, list, options);
 	}

 	setChildren(
 		element: T | null,
-		children: ISequence<ICompressedTreeElement<T>> | undefined,
-		onDidCreateNode?: (node: ITreeNode<ICompressedTreeNode<T>, TFilterData>) => void,
-		onDidDeleteNode?: (node: ITreeNode<ICompressedTreeNode<T>, TFilterData>) => void
-	): Iterator<ITreeElement<T | null>> {
+		children: ISequence<ICompressedTreeElement<T>> | undefined
+	): void {
+
+		if (element === null) {
+			const compressedChildren = Iterator.map(Iterator.from(children), this.enabled ? compress : noCompress);
+			this._setChildren(null, compressedChildren);
+			return;
+		}
+
+		const compressedNode = this.nodes.get(element);
+
+		if (!compressedNode) {
+			throw new Error('Unknown compressed tree node');
+		}
+
+		const node = this.model.getNode(compressedNode) as ITreeNode<ICompressedTreeNode<T>, TFilterData>;
+		const compressedParentNode = this.model.getParentNodeLocation(compressedNode);
+		const parent = this.model.getNode(compressedParentNode) as ITreeNode<ICompressedTreeNode<T>, TFilterData>;
+
+		const decompressedElement = decompress(node);
+		const splicedElement = splice(decompressedElement, element, Iterator.from(children));
+		const recompressedElement = (this.enabled ? compress : noCompress)(splicedElement);
+
+		const parentChildren = parent.children
+			.map(child => child === node ? recompressedElement : child);
+
+		this._setChildren(parent.element, parentChildren);
+	}
+
+	isCompressionEnabled(): boolean {
+		return this.enabled;
+	}
+
+	setCompressionEnabled(enabled: boolean): void {
+		if (enabled === this.enabled) {
+			return;
+		}
+
+		this.enabled = enabled;
+
+		const root = this.model.getNode();
+		const rootChildren = Iterator.from((root.children as unknown) as ITreeNode<ICompressedTreeNode<T>>[]); // {{SQL CARBON EDIT}} strict-null-checks
+		const decompressedRootChildren = Iterator.map(rootChildren, decompress);
+		const recompressedRootChildren = Iterator.map(decompressedRootChildren, enabled ? compress : noCompress);
+		this._setChildren(null, recompressedRootChildren);
+	}
+
+	private _setChildren(
+		node: ICompressedTreeNode<T> | null,
+		children: ISequence<ITreeElement<ICompressedTreeNode<T>>> | undefined
+	): void {
 		const insertedElements = new Set<T | null>();
 		const _onDidCreateNode = (node: ITreeNode<ICompressedTreeNode<T>, TFilterData>) => {
 			for (const element of node.element.elements) {
 				insertedElements.add(element);
 				this.nodes.set(element, node.element);
 			}
-
-			// if (this.identityProvider) {
-			// 	const id = this.identityProvider.getId(node.element).toString();
-			// 	insertedElementIds.add(id);
-			// 	this.nodesByIdentity.set(id, node);
-			// }
-
-			if (onDidCreateNode) {
-				onDidCreateNode(node);
-			}
 		};

 		const _onDidDeleteNode = (node: ITreeNode<ICompressedTreeNode<T>, TFilterData>) => {
@@ -129,40 +186,9 @@ export class CompressedTreeModel<T extends NonNullable<any>, TFilterData extends
 					this.nodes.delete(element);
 				}
 			}
-
-			// if (this.identityProvider) {
-			// 	const id = this.identityProvider.getId(node.element).toString();
-			// 	if (!insertedElementIds.has(id)) {
-			// 		this.nodesByIdentity.delete(id);
-			// 	}
-			// }
-
-			if (onDidDeleteNode) {
-				onDidDeleteNode(node);
-			}
 		};

-		if (element === null) {
-			const compressedChildren = Iterator.map(Iterator.from(children), compress);
-			const result = this.model.setChildren(null, compressedChildren, _onDidCreateNode, _onDidDeleteNode);
-			return Iterator.map(result, decompress);
-		}
-
-		const compressedNode = this.nodes.get(element);
-		const node = this.model.getNode(compressedNode) as ITreeNode<ICompressedTreeNode<T>, TFilterData>;
-		const parent = node.parent!;
-
-		const decompressedElement = decompress(node);
-		const splicedElement = splice(decompressedElement, element, Iterator.from(children));
-		const recompressedElement = compress(splicedElement);
-
-		const parentChildren = parent.children
-			.map(child => child === node ? recompressedElement : child);
-
-		this.model.setChildren(parent.element, parentChildren, _onDidCreateNode, _onDidDeleteNode);
-
-		// TODO
-		return Iterator.empty();
+		this.model.setChildren(node, children, _onDidCreateNode, _onDidDeleteNode);
 	}

 	getListIndex(location: T | null): number {
@@ -207,11 +233,6 @@ export class CompressedTreeModel<T extends NonNullable<any>, TFilterData extends
 		return parentNode.elements[parentNode.elements.length - 1];
 	}

-	getParentElement(location: T | null): ICompressedTreeNode<T> | null {
-		const compressedNode = this.getCompressedNode(location);
-		return this.model.getParentElement(compressedNode);
-	}
-
 	getFirstElementChild(location: T | null): ICompressedTreeNode<T> | null | undefined {
 		const compressedNode = this.getCompressedNode(location);
 		return this.model.getFirstElementChild(compressedNode);
@@ -227,6 +248,11 @@ export class CompressedTreeModel<T extends NonNullable<any>, TFilterData extends
 		return this.model.isCollapsible(compressedNode);
 	}

+	setCollapsible(location: T | null, collapsible?: boolean): boolean {
+		const compressedNode = this.getCompressedNode(location);
+		return this.model.setCollapsible(compressedNode, collapsible);
+	}
+
 	isCollapsed(location: T | null): boolean {
 		const compressedNode = this.getCompressedNode(location);
 		return this.model.isCollapsed(compressedNode);
@@ -256,7 +282,7 @@ export class CompressedTreeModel<T extends NonNullable<any>, TFilterData extends
 		this.model.resort(compressedNode, recursive);
 	}

-	private getCompressedNode(element: T | null): ICompressedTreeNode<T> | null {
+	getCompressedNode(element: T | null): ICompressedTreeNode<T> | null {
 		if (element === null) {
 			return null;
 		}
@@ -264,78 +290,120 @@ export class CompressedTreeModel<T extends NonNullable<any>, TFilterData extends
 		const node = this.nodes.get(element);

 		if (!node) {
-			throw new Error(`Tree element not found: ${element}`);
+			throw new TreeError(this.user, `Tree element not found: ${element}`);
 		}

 		return node;
 	}
 }

+// Compressible Object Tree
+
 export type ElementMapper<T> = (elements: T[]) => T;
 export const DefaultElementMapper: ElementMapper<any> = elements => elements[elements.length - 1];

-export type NodeMapper<T, TFilterData> = (node: ITreeNode<ICompressedTreeNode<T> | null, TFilterData>) => ITreeNode<T | null, TFilterData>;
+export type CompressedNodeUnwrapper<T> = (node: ICompressedTreeNode<T>) => T;
+type CompressedNodeWeakMapper<T, TFilterData> = WeakMapper<ITreeNode<ICompressedTreeNode<T> | null, TFilterData>, ITreeNode<T | null, TFilterData>>;

-function mapNode<T, TFilterData>(elementMapper: ElementMapper<T>, node: ITreeNode<ICompressedTreeNode<T> | null, TFilterData>): ITreeNode<T | null, TFilterData> {
+class CompressedTreeNodeWrapper<T, TFilterData> implements ITreeNode<T | null, TFilterData> {
+
+	get element(): T | null { return this.node.element === null ? null : this.unwrapper(this.node.element); }
+	get children(): ITreeNode<T | null, TFilterData>[] { return this.node.children.map(node => new CompressedTreeNodeWrapper(this.unwrapper, node)); }
+	get depth(): number { return this.node.depth; }
+	get visibleChildrenCount(): number { return this.node.visibleChildrenCount; }
+	get visibleChildIndex(): number { return this.node.visibleChildIndex; }
+	get collapsible(): boolean { return this.node.collapsible; }
+	get collapsed(): boolean { return this.node.collapsed; }
+	get visible(): boolean { return this.node.visible; }
+	get filterData(): TFilterData | undefined { return this.node.filterData; }
+
+	constructor(
+		private unwrapper: CompressedNodeUnwrapper<T>,
+		private node: ITreeNode<ICompressedTreeNode<T> | null, TFilterData>
+	) { }
+}
+
+function mapList<T, TFilterData>(nodeMapper: CompressedNodeWeakMapper<T, TFilterData>, list: ISpliceable<ITreeNode<T, TFilterData>>): ISpliceable<ITreeNode<ICompressedTreeNode<T>, TFilterData>> {
 	return {
-		...node,
-		element: node.element === null ? null : elementMapper(node.element.elements),
-		children: node.children.map(child => mapNode(elementMapper, child)),
-		parent: typeof node.parent === 'undefined' ? node.parent : mapNode(elementMapper, node.parent)
+		splice(start: number, deleteCount: number, toInsert: ITreeNode<ICompressedTreeNode<T>, TFilterData>[]): void {
+			list.splice(start, deleteCount, toInsert.map(node => nodeMapper.map(node)) as ITreeNode<T, TFilterData>[]);
+		}
 	};
 }

-function createNodeMapper<T, TFilterData>(elementMapper: ElementMapper<T>): NodeMapper<T, TFilterData> {
-	return node => mapNode(elementMapper, node);
+function mapOptions<T, TFilterData>(compressedNodeUnwrapper: CompressedNodeUnwrapper<T>, options: ICompressibleObjectTreeModelOptions<T, TFilterData>): ICompressedObjectTreeModelOptions<T, TFilterData> {
+	return {
+		...options,
+		sorter: options.sorter && {
+			compare(node: ICompressedTreeNode<T>, otherNode: ICompressedTreeNode<T>): number {
+				return options.sorter!.compare(compressedNodeUnwrapper(node), compressedNodeUnwrapper(otherNode));
+			}
+		},
+		identityProvider: options.identityProvider && {
+			getId(node: ICompressedTreeNode<T>): { toString(): string; } {
+				return options.identityProvider!.getId(compressedNodeUnwrapper(node));
+			}
+		},
+		filter: options.filter && {
+			filter(node: ICompressedTreeNode<T>, parentVisibility: TreeVisibility): TreeFilterResult<TFilterData> {
+				return options.filter!.filter(compressedNodeUnwrapper(node), parentVisibility);
+			}
+		}
+	};
 }

-export interface ICompressedObjectTreeModelOptions<T, TFilterData> extends ICompressedTreeModelOptions<T, TFilterData> {
+export interface ICompressibleObjectTreeModelOptions<T, TFilterData> extends IObjectTreeModelOptions<T, TFilterData> {
 	readonly elementMapper?: ElementMapper<T>;
 }

-export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData extends NonNullable<any> = void> implements IObjectTreeModel<T, TFilterData> {
+export class CompressibleObjectTreeModel<T extends NonNullable<any>, TFilterData extends NonNullable<any> = void> implements IObjectTreeModel<T, TFilterData> {

 	readonly rootRef = null;

 	get onDidSplice(): Event<ITreeModelSpliceEvent<T | null, TFilterData>> {
 		return Event.map(this.model.onDidSplice, ({ insertedNodes, deletedNodes }) => ({
-			insertedNodes: insertedNodes.map(this.mapNode),
-			deletedNodes: deletedNodes.map(this.mapNode),
+			insertedNodes: insertedNodes.map(node => this.nodeMapper.map(node)),
+			deletedNodes: deletedNodes.map(node => this.nodeMapper.map(node)),
 		}));
 	}

 	get onDidChangeCollapseState(): Event<ICollapseStateChangeEvent<T | null, TFilterData>> {
 		return Event.map(this.model.onDidChangeCollapseState, ({ node, deep }) => ({
-			node: this.mapNode(node),
+			node: this.nodeMapper.map(node),
 			deep
 		}));
 	}

 	get onDidChangeRenderNodeCount(): Event<ITreeNode<T | null, TFilterData>> {
-		return Event.map(this.model.onDidChangeRenderNodeCount, this.mapNode);
+		return Event.map(this.model.onDidChangeRenderNodeCount, node => this.nodeMapper.map(node));
 	}

-	private mapElement: ElementMapper<T | null>;
-	private mapNode: NodeMapper<T | null, TFilterData>;
-	private model: CompressedTreeModel<T, TFilterData>;
+	private elementMapper: ElementMapper<T>;
+	private nodeMapper: CompressedNodeWeakMapper<T, TFilterData>;
+	private model: CompressedObjectTreeModel<T, TFilterData>;

 	constructor(
-		list: ISpliceable<ITreeNode<ICompressedTreeNode<T>, TFilterData>>,
-		options: ICompressedObjectTreeModelOptions<T, TFilterData> = {}
+		user: string,
+		list: ISpliceable<ITreeNode<T, TFilterData>>,
+		options: ICompressibleObjectTreeModelOptions<T, TFilterData> = {}
 	) {
-		this.mapElement = options.elementMapper || DefaultElementMapper;
-		this.mapNode = createNodeMapper(this.mapElement);
-		this.model = new CompressedTreeModel(list, options);
+		this.elementMapper = options.elementMapper || DefaultElementMapper;
+		const compressedNodeUnwrapper: CompressedNodeUnwrapper<T> = node => this.elementMapper(node.elements);
+		this.nodeMapper = new WeakMapper(node => new CompressedTreeNodeWrapper(compressedNodeUnwrapper, node));
+
+		this.model = new CompressedObjectTreeModel(user, mapList(this.nodeMapper, list), mapOptions(compressedNodeUnwrapper, options));
 	}

-	setChildren(
-		element: T | null,
-		children: ISequence<ITreeElement<T>> | undefined
-	): Iterator<ITreeElement<T>> {
+	setChildren(element: T | null, children?: ISequence<ICompressedTreeElement<T>>): void {
 		this.model.setChildren(element, children);
+	}

-		// TODO
-		return Iterator.empty();
+	isCompressionEnabled(): boolean {
+		return this.model.isCompressionEnabled();
+	}
+
+	setCompressionEnabled(enabled: boolean): void {
+		this.model.setCompressionEnabled(enabled);
 	}

 	getListIndex(location: T | null): number {
@@ -347,7 +415,7 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
 	}

 	getNode(location?: T | null | undefined): ITreeNode<T | null, any> {
-		return this.mapNode(this.model.getNode(location));
+		return this.nodeMapper.map(this.model.getNode(location));
 	}

 	getNodeLocation(node: ITreeNode<T | null, any>): T | null {
@@ -358,16 +426,6 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
 		return this.model.getParentNodeLocation(location);
 	}

-	getParentElement(location: T | null): T | null {
-		const result = this.model.getParentElement(location);
-
-		if (result === null) {
-			return null; // {{SQL CARBON EDIT}} strict-null-check
-		}
-
-		return this.mapElement(result.elements);
-	}
-
 	getFirstElementChild(location: T | null): T | null | undefined {
 		const result = this.model.getFirstElementChild(location);

@@ -375,7 +433,7 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
 			return null; // {{SQL CARBON EDIT}} strict-null-check
 		}

-		return this.mapElement(result.elements);
+		return this.elementMapper(result.elements);
 	}

 	getLastElementAncestor(location?: T | null | undefined): T | null | undefined {
@@ -385,13 +443,17 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
 			return null; // {{SQL CARBON EDIT}} strict-null-check
 		}

-		return this.mapElement(result.elements);
+		return this.elementMapper(result.elements);
 	}

 	isCollapsible(location: T | null): boolean {
 		return this.model.isCollapsible(location);
 	}

+	setCollapsible(location: T | null, collapsed?: boolean): boolean {
+		return this.model.setCollapsible(location, collapsed);
+	}
+
 	isCollapsed(location: T | null): boolean {
 		return this.model.isCollapsed(location);
 	}
@@ -415,4 +477,8 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
 	resort(element: T | null = null, recursive = true): void {
 		return this.model.resort(element, recursive);
 	}
-}
+
+	getCompressedTreeNode(element: T): ITreeNode<ICompressedTreeNode<T>, TFilterData> {
+		return this.model.getNode(element) as ITreeNode<ICompressedTreeNode<T>, TFilterData>;
+	}
+}