Merge pull request #94540 from microsoft/joao/iterator

Adopt native iterators across the workbench

src/vs/base/browser/ui/tree/asyncDataTree.ts

@@ -11,7 +11,7 @@ import { IDisposable, dispose, DisposableStore } from 'vs/base/common/lifecycle'
 import { Emitter, Event } from 'vs/base/common/event';
 import { timeout, CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
 import { IListStyles } from 'vs/base/browser/ui/list/listWidget';
-import { Iterator } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { IDragAndDropData } from 'vs/base/browser/dnd';
 import { ElementsDragAndDropData } from 'vs/base/browser/ui/list/listView';
 import { isPromiseCanceledError, onUnexpectedError } from 'vs/base/common/errors';
@@ -943,7 +943,7 @@ export class AsyncDataTree<TInput, T, TFilterData = void> implements IDisposable
 
 		return {
 			element: node,
-			children: node.hasChildren ? Iterator.map(Iterator.fromArray(node.children), child => this.asTreeElement(child, viewStateContext)) : [],
+			children: node.hasChildren ? Iterable.map(node.children, child => this.asTreeElement(child, viewStateContext)) : [],
 			collapsible: node.hasChildren,
 			collapsed
 		};

src/vs/base/browser/ui/tree/compressedObjectTreeModel.ts

@@ -4,14 +4,14 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ISpliceable } from 'vs/base/common/sequence';
-import { Iterator, ISequence } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { Event } from 'vs/base/common/event';
 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?: ISequence<ICompressedTreeElement<T>>;
+	readonly children?: Iterable<ICompressedTreeElement<T>>;
 	readonly incompressible?: boolean;
 }
 
@@ -27,7 +27,7 @@ function noCompress<T>(element: ICompressedTreeElement<T>): ITreeElement<ICompre
 
 	return {
 		element: { elements, incompressible },
-		children: Iterator.map(Iterator.from(element.children), noCompress),
+		children: Iterable.map(Iterable.from(element.children), noCompress),
 		collapsible: element.collapsible,
 		collapsed: element.collapsed
 	};
@@ -38,12 +38,11 @@ export function compress<T>(element: ICompressedTreeElement<T>): ITreeElement<IC
 	const elements = [element.element];
 	const incompressible = element.incompressible || false;
 
-	let childrenIterator: Iterator<ITreeElement<T>>;
+	let childrenIterator: Iterable<ITreeElement<T>>;
 	let children: ITreeElement<T>[];
 
 	while (true) {
-		childrenIterator = Iterator.from(element.children);
-		children = Iterator.collect(childrenIterator, 2);
+		[children, childrenIterator] = Iterable.consume(Iterable.from(element.children), 2);
 
 		if (children.length !== 1) {
 			break;
@@ -60,19 +59,19 @@ export function compress<T>(element: ICompressedTreeElement<T>): ITreeElement<IC
 
 	return {
 		element: { elements, incompressible },
-		children: Iterator.map(Iterator.concat(Iterator.fromArray(children), childrenIterator), compress),
+		children: Iterable.map(Iterable.concat(children, childrenIterator), compress),
 		collapsible: element.collapsible,
 		collapsed: element.collapsed
 	};
 }
 
 function _decompress<T>(element: ITreeElement<ICompressedTreeNode<T>>, index = 0): ICompressedTreeElement<T> {
-	let children: Iterator<ICompressedTreeElement<T>>;
+	let children: Iterable<ICompressedTreeElement<T>>;
 
 	if (index < element.element.elements.length - 1) {
-		children = Iterator.single(_decompress(element, index + 1));
+		children = [_decompress(element, index + 1)];
 	} else {
-		children = Iterator.map(Iterator.from(element.children), el => _decompress(el, 0));
+		children = Iterable.map(Iterable.from(element.children), el => _decompress(el, 0));
 	}
 
 	if (index === 0 && element.element.incompressible) {
@@ -98,12 +97,12 @@ export function decompress<T>(element: ITreeElement<ICompressedTreeNode<T>>): IC
 	return _decompress(element, 0);
 }
 
-function splice<T>(treeElement: ICompressedTreeElement<T>, element: T, children: Iterator<ICompressedTreeElement<T>>): ICompressedTreeElement<T> {
+function splice<T>(treeElement: ICompressedTreeElement<T>, element: T, children: Iterable<ICompressedTreeElement<T>>): ICompressedTreeElement<T> {
 	if (treeElement.element === element) {
 		return { ...treeElement, children };
 	}
 
-	return { ...treeElement, children: Iterator.map(Iterator.from(treeElement.children), e => splice(e, element, children)) };
+	return { ...treeElement, children: Iterable.map(Iterable.from(treeElement.children), e => splice(e, element, children)) };
 }
 
 interface ICompressedObjectTreeModelOptions<T, TFilterData> extends IObjectTreeModelOptions<ICompressedTreeNode<T>, TFilterData> {
@@ -136,10 +135,10 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
 
 	setChildren(
 		element: T | null,
-		children: ISequence<ICompressedTreeElement<T>> | undefined
+		children: Iterable<ICompressedTreeElement<T>> = Iterable.empty()
 	): void {
 		if (element === null) {
-			const compressedChildren = Iterator.map(Iterator.from(children), this.enabled ? compress : noCompress);
+			const compressedChildren = Iterable.map(children, this.enabled ? compress : noCompress);
 			this._setChildren(null, compressedChildren);
 			return;
 		}
@@ -155,7 +154,7 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
 		const parent = this.model.getNode(compressedParentNode) as ITreeNode<ICompressedTreeNode<T>, TFilterData>;
 
 		const decompressedElement = decompress(node);
-		const splicedElement = splice(decompressedElement, element, Iterator.from(children));
+		const splicedElement = splice(decompressedElement, element, children);
 		const recompressedElement = (this.enabled ? compress : noCompress)(splicedElement);
 
 		const parentChildren = parent.children
@@ -176,15 +175,15 @@ export class CompressedObjectTreeModel<T extends NonNullable<any>, TFilterData e
 		this.enabled = enabled;
 
 		const root = this.model.getNode();
-		const rootChildren = Iterator.from(root.children as ITreeNode<ICompressedTreeNode<T>>[]);
-		const decompressedRootChildren = Iterator.map(rootChildren, decompress);
-		const recompressedRootChildren = Iterator.map(decompressedRootChildren, enabled ? compress : noCompress);
+		const rootChildren = root.children as ITreeNode<ICompressedTreeNode<T>>[];
+		const decompressedRootChildren = Iterable.map(rootChildren, decompress);
+		const recompressedRootChildren = Iterable.map(decompressedRootChildren, enabled ? compress : noCompress);
 		this._setChildren(null, recompressedRootChildren);
 	}
 
 	private _setChildren(
 		node: ICompressedTreeNode<T> | null,
-		children: ISequence<ITreeElement<ICompressedTreeNode<T>>> | undefined
+		children: Iterable<ITreeElement<ICompressedTreeNode<T>>>
 	): void {
 		const insertedElements = new Set<T | null>();
 		const _onDidCreateNode = (node: ITreeNode<ICompressedTreeNode<T>, TFilterData>) => {
@@ -413,7 +412,7 @@ export class CompressibleObjectTreeModel<T extends NonNullable<any>, TFilterData
 		this.model = new CompressedObjectTreeModel(user, mapList(this.nodeMapper, list), mapOptions(compressedNodeUnwrapper, options));
 	}
 
-	setChildren(element: T | null, children?: ISequence<ICompressedTreeElement<T>>): void {
+	setChildren(element: T | null, children: Iterable<ICompressedTreeElement<T>> = Iterable.empty()): void {
 		this.model.setChildren(element, children);
 	}
 

src/vs/base/browser/ui/tree/dataTree.ts

@@ -8,7 +8,7 @@ import { ISpliceable } from 'vs/base/common/sequence';
 import { ITreeNode, ITreeModel, ITreeElement, ITreeRenderer, ITreeSorter, IDataSource, TreeError } from 'vs/base/browser/ui/tree/tree';
 import { ObjectTreeModel } from 'vs/base/browser/ui/tree/objectTreeModel';
 import { IListVirtualDelegate, IIdentityProvider } from 'vs/base/browser/ui/list/list';
-import { Iterator } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 
 export interface IDataTreeOptions<T, TFilterData = void> extends IAbstractTreeOptions<T, TFilterData> {
 	readonly sorter?: ITreeSorter<T>;
@@ -158,9 +158,9 @@ export class DataTree<TInput, T, TFilterData = void> extends AbstractTree<T | nu
 		this.model.setChildren((element === this.input ? null : element) as T, this.iterate(element, isCollapsed).elements, onDidCreateNode, onDidDeleteNode);
 	}
 
-	private iterate(element: TInput | T, isCollapsed?: (el: T) => boolean | undefined): { elements: Iterator<ITreeElement<T>>, size: number } {
+	private iterate(element: TInput | T, isCollapsed?: (el: T) => boolean | undefined): { elements: Iterable<ITreeElement<T>>, size: number } {
 		const children = this.dataSource.getChildren(element);
-		const elements = Iterator.map<any, ITreeElement<T>>(Iterator.fromArray(children), element => {
+		const elements = Iterable.map(children, element => {
 			const { elements: children, size } = this.iterate(element, isCollapsed);
 			const collapsible = this.dataSource.hasChildren ? this.dataSource.hasChildren(element) : undefined;
 			const collapsed = size === 0 ? undefined : (isCollapsed && isCollapsed(element));

src/vs/base/browser/ui/tree/indexTree.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import 'vs/css!./media/tree';
-import { Iterator, ISequence } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { AbstractTree, IAbstractTreeOptions } from 'vs/base/browser/ui/tree/abstractTree';
 import { ISpliceable } from 'vs/base/common/sequence';
 import { IndexTreeModel } from 'vs/base/browser/ui/tree/indexTreeModel';
@@ -28,7 +28,7 @@ export class IndexTree<T, TFilterData = void> extends AbstractTree<T, TFilterDat
 		super(user, container, delegate, renderers, options);
 	}
 
-	splice(location: number[], deleteCount: number, toInsert: ISequence<ITreeElement<T>> = Iterator.empty()): void {
+	splice(location: number[], deleteCount: number, toInsert: Iterable<ITreeElement<T>> = Iterable.empty()): void {
 		this.model.splice(location, deleteCount, toInsert);
 	}
 

src/vs/base/browser/ui/tree/indexTreeModel.ts

@@ -6,7 +6,7 @@
 import { ICollapseStateChangeEvent, ITreeElement, ITreeFilter, ITreeFilterDataResult, ITreeModel, ITreeNode, TreeVisibility, ITreeModelSpliceEvent, TreeError } from 'vs/base/browser/ui/tree/tree';
 import { tail2 } from 'vs/base/common/arrays';
 import { Emitter, Event, EventBufferer } from 'vs/base/common/event';
-import { ISequence, Iterator } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { ISpliceable } from 'vs/base/common/sequence';
 
 // Exported for tests
@@ -103,7 +103,7 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
 	splice(
 		location: number[],
 		deleteCount: number,
-		toInsert?: ISequence<ITreeElement<T>>,
+		toInsert: Iterable<ITreeElement<T>> = Iterable.empty(),
 		onDidCreateNode?: (node: ITreeNode<T, TFilterData>) => void,
 		onDidDeleteNode?: (node: ITreeNode<T, TFilterData>) => void
 	): void {
@@ -113,7 +113,7 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
 
 		const { parentNode, listIndex, revealed, visible } = this.getParentNodeWithListIndex(location);
 		const treeListElementsToInsert: ITreeNode<T, TFilterData>[] = [];
-		const nodesToInsertIterator = Iterator.map(Iterator.from(toInsert), el => this.createTreeNode(el, parentNode, parentNode.visible ? TreeVisibility.Visible : TreeVisibility.Hidden, revealed, treeListElementsToInsert, onDidCreateNode));
+		const nodesToInsertIterator = Iterable.map(toInsert, el => this.createTreeNode(el, parentNode, parentNode.visible ? TreeVisibility.Visible : TreeVisibility.Hidden, revealed, treeListElementsToInsert, onDidCreateNode));
 
 		const lastIndex = location[location.length - 1];
 
@@ -134,14 +134,14 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
 		let insertedVisibleChildrenCount = 0;
 		let renderNodeCount = 0;
 
-		Iterator.forEach(nodesToInsertIterator, child => {
+		for (const child of nodesToInsertIterator) {
 			nodesToInsert.push(child);
 			renderNodeCount += child.renderNodeCount;
 
 			if (child.visible) {
 				child.visibleChildIndex = visibleChildStartIndex + insertedVisibleChildrenCount++;
 			}
-		});
+		}
 
 		const deletedNodes = parentNode.children.splice(lastIndex, deleteCount, ...nodesToInsert);
 
@@ -365,21 +365,21 @@ export class IndexTreeModel<T extends Exclude<any, undefined>, TFilterData = voi
 			treeListElements.push(node);
 		}
 
-		const childElements = Iterator.from(treeElement.children);
+		const childElements = treeElement.children || Iterable.empty();
 		const childRevealed = revealed && visibility !== TreeVisibility.Hidden && !node.collapsed;
-		const childNodes = Iterator.map(childElements, el => this.createTreeNode(el, node, visibility, childRevealed, treeListElements, onDidCreateNode));
+		const childNodes = Iterable.map(childElements, el => this.createTreeNode(el, node, visibility, childRevealed, treeListElements, onDidCreateNode));
 
 		let visibleChildrenCount = 0;
 		let renderNodeCount = 1;
 
-		Iterator.forEach(childNodes, child => {
+		for (const child of childNodes) {
 			node.children.push(child);
 			renderNodeCount += child.renderNodeCount;
 
 			if (child.visible) {
 				child.visibleChildIndex = visibleChildrenCount++;
 			}
-		});
+		}
 
 		node.collapsible = node.collapsible || node.children.length > 0;
 		node.visibleChildrenCount = visibleChildrenCount;

src/vs/base/browser/ui/tree/objectTree.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { ISequence } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { AbstractTree, IAbstractTreeOptions, IAbstractTreeOptionsUpdate } from 'vs/base/browser/ui/tree/abstractTree';
 import { ISpliceable } from 'vs/base/common/sequence';
 import { ITreeNode, ITreeModel, ITreeElement, ITreeRenderer, ITreeSorter, ICollapseStateChangeEvent } from 'vs/base/browser/ui/tree/tree';
@@ -33,7 +33,7 @@ export class ObjectTree<T extends NonNullable<any>, TFilterData = void> extends
 		super(user, container, delegate, renderers, options as IObjectTreeOptions<T | null, TFilterData>);
 	}
 
-	setChildren(element: T | null, children?: ISequence<ITreeElement<T>>): void {
+	setChildren(element: T | null, children: Iterable<ITreeElement<T>> = Iterable.empty()): void {
 		this.model.setChildren(element, children);
 	}
 
@@ -184,7 +184,7 @@ export class CompressibleObjectTree<T extends NonNullable<any>, TFilterData = vo
 		super(user, container, delegate, compressibleRenderers, asObjectTreeOptions<T, TFilterData>(compressedTreeNodeProvider, options));
 	}
 
-	setChildren(element: T | null, children?: ISequence<ICompressedTreeElement<T>>): void {
+	setChildren(element: T | null, children: Iterable<ICompressedTreeElement<T>> = Iterable.empty()): void {
 		this.model.setChildren(element, children);
 	}
 

src/vs/base/browser/ui/tree/objectTreeModel.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { ISpliceable } from 'vs/base/common/sequence';
-import { Iterator, ISequence, getSequenceIterator } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { IndexTreeModel, IIndexTreeModelOptions } from 'vs/base/browser/ui/tree/indexTreeModel';
 import { Event } from 'vs/base/common/event';
 import { ITreeModel, ITreeNode, ITreeElement, ITreeSorter, ICollapseStateChangeEvent, ITreeModelSpliceEvent, TreeError } from 'vs/base/browser/ui/tree/tree';
@@ -14,7 +14,7 @@ import { mergeSort } from 'vs/base/common/arrays';
 export type ITreeNodeCallback<T, TFilterData> = (node: ITreeNode<T, TFilterData>) => void;
 
 export interface IObjectTreeModel<T extends NonNullable<any>, TFilterData extends NonNullable<any> = void> extends ITreeModel<T | null, TFilterData, T | null> {
-	setChildren(element: T | null, children: ISequence<ITreeElement<T>> | undefined): void;
+	setChildren(element: T | null, children: Iterable<ITreeElement<T>> | undefined): void;
 	resort(element?: T | null, recursive?: boolean): void;
 }
 
@@ -62,7 +62,7 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
 
 	setChildren(
 		element: T | null,
-		children: ISequence<ITreeElement<T>> | undefined,
+		children: Iterable<ITreeElement<T>> = Iterable.empty(),
 		onDidCreateNode?: ITreeNodeCallback<T, TFilterData>,
 		onDidDeleteNode?: ITreeNodeCallback<T, TFilterData>
 	): void {
@@ -72,7 +72,7 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
 
 	private _setChildren(
 		location: number[],
-		children: ISequence<ITreeElement<T>> | undefined,
+		children: Iterable<ITreeElement<T>> = Iterable.empty(),
 		onDidCreateNode?: ITreeNodeCallback<T, TFilterData>,
 		onDidDeleteNode?: ITreeNodeCallback<T, TFilterData>
 	): void {
@@ -132,14 +132,12 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
 		);
 	}
 
-	private preserveCollapseState(elements: ISequence<ITreeElement<T>> | undefined): ISequence<ITreeElement<T>> {
-		let iterator = elements ? getSequenceIterator(elements) : Iterator.empty<ITreeElement<T>>();
-
+	private preserveCollapseState(elements: Iterable<ITreeElement<T>> = Iterable.empty()): Iterable<ITreeElement<T>> {
 		if (this.sorter) {
-			iterator = Iterator.fromArray(mergeSort(Iterator.collect(iterator), this.sorter.compare.bind(this.sorter)));
+			elements = mergeSort([...elements], this.sorter.compare.bind(this.sorter));
 		}
 
-		return Iterator.map(iterator, treeElement => {
+		return Iterable.map(elements, treeElement => {
 			let node = this.nodes.get(treeElement.element);
 
 			if (!node && this.identityProvider) {
@@ -182,14 +180,14 @@ export class ObjectTreeModel<T extends NonNullable<any>, TFilterData extends Non
 		this._setChildren(location, this.resortChildren(node, recursive));
 	}
 
-	private resortChildren(node: ITreeNode<T | null, TFilterData>, recursive: boolean, first = true): ISequence<ITreeElement<T>> {
-		let childrenNodes = Iterator.fromArray(node.children as ITreeNode<T, TFilterData>[]);
+	private resortChildren(node: ITreeNode<T | null, TFilterData>, recursive: boolean, first = true): Iterable<ITreeElement<T>> {
+		let childrenNodes = [...node.children] as ITreeNode<T, TFilterData>[];
 
 		if (recursive || first) {
-			childrenNodes = Iterator.fromArray(Iterator.collect(childrenNodes).sort(this.sorter!.compare.bind(this.sorter)));
+			childrenNodes = mergeSort(childrenNodes, this.sorter!.compare.bind(this.sorter));
 		}
 
-		return Iterator.map<ITreeNode<T | null, TFilterData>, ITreeElement<T>>(childrenNodes, node => ({
+		return Iterable.map<ITreeNode<T | null, TFilterData>, ITreeElement<T>>(childrenNodes, node => ({
 			element: node.element as T,
 			collapsible: node.collapsible,
 			collapsed: node.collapsed,

src/vs/base/browser/ui/tree/tree.ts

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { Event } from 'vs/base/common/event';
-import { Iterator } from 'vs/base/common/iterator';
 import { IListRenderer, IListDragOverReaction, IListDragAndDrop, ListDragOverEffect } from 'vs/base/browser/ui/list/list';
 import { IDragAndDropData } from 'vs/base/browser/dnd';
 
@@ -74,7 +73,7 @@ export interface ITreeSorter<T> {
 
 export interface ITreeElement<T> {
 	readonly element: T;
-	readonly children?: Iterator<ITreeElement<T>> | ITreeElement<T>[];
+	readonly children?: Iterable<ITreeElement<T>>;
 	readonly collapsible?: boolean;
 	readonly collapsed?: boolean;
 }

src/vs/base/common/iterator.ts

@@ -3,37 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-export interface IteratorDefinedResult<T> {
-	readonly done: false;
-	readonly value: T;
-}
-export interface IteratorUndefinedResult {
-	readonly done: true;
-	readonly value: undefined;
-}
-export const FIN: IteratorUndefinedResult = { done: true, value: undefined };
-export type IteratorResult<T> = IteratorDefinedResult<T> | IteratorUndefinedResult;
-
-export interface Iterator<T> {
-	next(): IteratorResult<T>;
-}
-
-interface NativeIteratorYieldResult<TYield> {
-	done?: false;
-	value: TYield;
-}
-
-interface NativeIteratorReturnResult<TReturn> {
-	done: true;
-	value: TReturn;
-}
-
-type NativeIteratorResult<T, TReturn = any> = NativeIteratorYieldResult<T> | NativeIteratorReturnResult<TReturn>;
-
-export interface NativeIterator<T> {
-	next(): NativeIteratorResult<T>;
-}
-
 export namespace Iterable {
 
 	const _empty: Iterable<any> = Object.freeze([]);
@@ -41,6 +10,10 @@ export namespace Iterable {
 		return _empty;
 	}
 
+	export function from<T>(iterable: Iterable<T> | undefined | null): Iterable<T> {
+		return iterable || _empty;
+	}
+
 	export function first<T>(iterable: Iterable<T>): T | undefined {
 		return iterable[Symbol.iterator]().next().value;
 	}
@@ -67,183 +40,39 @@ export namespace Iterable {
 			yield fn(element);
 		}
 	}
-}
-
-export module Iterator {
-	const _empty: Iterator<any> = {
-		next() {
-			return FIN;
-		}
-	};
-
-	export function empty<T>(): Iterator<T> {
-		return _empty;
-	}
-
-	export function single<T>(value: T): Iterator<T> {
-		let done = false;
-
-		return {
-			next(): IteratorResult<T> {
-				if (done) {
-					return FIN;
-				}
-
-				done = true;
-				return { done: false, value };
-			}
-		};
-	}
-
-	export function fromArray<T>(array: ReadonlyArray<T>, index = 0, length = array.length): Iterator<T> {
-		return {
-			next(): IteratorResult<T> {
-				if (index >= length) {
-					return FIN;
-				}
-
-				return { done: false, value: array[index++] };
-			}
-		};
-	}
-
-	export function fromNativeIterator<T>(it: NativeIterator<T>): Iterator<T> {
-		return {
-			next(): IteratorResult<T> {
-				const result = it.next();
-
-				if (result.done) {
-					return FIN;
-				}
-
-				return { done: false, value: result.value };
-			}
-		};
-	}
-
-	export function from<T>(elements: Iterator<T> | T[] | undefined): Iterator<T> {
-		if (!elements) {
-			return Iterator.empty();
-		} else if (Array.isArray(elements)) {
-			return Iterator.fromArray(elements);
-		} else {
-			return elements;
-		}
-	}
-
-	export function map<T, R>(iterator: Iterator<T>, fn: (t: T) => R): Iterator<R> {
-		return {
-			next() {
-				const element = iterator.next();
-				if (element.done) {
-					return FIN;
-				} else {
-					return { done: false, value: fn(element.value) };
-				}
-			}
-		};
-	}
-
-	export function filter<T>(iterator: Iterator<T>, fn: (t: T) => boolean): Iterator<T> {
-		return {
-			next() {
-				while (true) {
-					const element = iterator.next();
-					if (element.done) {
-						return FIN;
-					}
-					if (fn(element.value)) {
-						return { done: false, value: element.value };
-					}
-				}
-			}
-		};
-	}
 
-	export function some<T>(iterator: Iterator<T> | NativeIterator<T>, fn: (t: T) => boolean): boolean {
-		while (true) {
-			const element = iterator.next();
-			if (element.done) {
-				return false;
-			}
-
-			if (fn(element.value)) {
-				return true;
+	export function* concat<T>(...iterables: Iterable<T>[]): Iterable<T> {
+		for (const iterable of iterables) {
+			for (const element of iterable) {
+				yield element;
 			}
 		}
 	}
 
-	export function forEach<T>(iterator: Iterator<T>, fn: (t: T) => void): void {
-		for (let next = iterator.next(); !next.done; next = iterator.next()) {
-			fn(next.value);
-		}
-	}
-
-	export function collect<T>(iterator: Iterator<T>, atMost: number = Number.POSITIVE_INFINITY): T[] {
-		const result: T[] = [];
+	/**
+	 * Consumes `atMost` elements from iterable and returns the consumed elements,
+	 * and an iterable for the rest of the elements.
+	 */
+	export function consume<T>(iterable: Iterable<T>, atMost: number = Number.POSITIVE_INFINITY): [T[], Iterable<T>] {
+		const consumed: T[] = [];
 
 		if (atMost === 0) {
-			return result;
-		}
-
-		let i = 0;
-
-		for (let next = iterator.next(); !next.done; next = iterator.next()) {
-			result.push(next.value);
-
-			if (++i >= atMost) {
-				break;
-			}
+			return [consumed, iterable];
 		}
 
-		return result;
-	}
+		const iterator = iterable[Symbol.iterator]();
 
-	export function concat<T>(...iterators: Iterator<T>[]): Iterator<T> {
-		let i = 0;
+		for (let i = 0; i < atMost; i++) {
+			const next = iterator.next();
 
-		return {
-			next() {
-				if (i >= iterators.length) {
-					return FIN;
-				}
-
-				const iterator = iterators[i];
-				const result = iterator.next();
-
-				if (result.done) {
-					i++;
-					return this.next();
-				}
-
-				return result;
+			if (next.done) {
+				return [consumed, Iterable.empty()];
 			}
-		};
-	}
 
-	export function chain<T>(iterator: Iterator<T>): ChainableIterator<T> {
-		return new ChainableIterator(iterator);
-	}
-}
-
-export class ChainableIterator<T> implements Iterator<T> {
-
-	constructor(private it: Iterator<T>) { }
-
-	next(): IteratorResult<T> { return this.it.next(); }
-	map<R>(fn: (t: T) => R): ChainableIterator<R> { return new ChainableIterator(Iterator.map(this.it, fn)); }
-	filter(fn: (t: T) => boolean): ChainableIterator<T> { return new ChainableIterator(Iterator.filter(this.it, fn)); }
-}
-
-export type ISequence<T> = Iterator<T> | T[];
+			consumed.push(next.value);
+		}
 
-export function getSequenceIterator<T>(arg: ISequence<T> | undefined): Iterator<T> {
-	if (Array.isArray(arg)) {
-		return Iterator.fromArray(arg);
-	} else if (!arg) {
-		return Iterator.empty();
-	} else {
-		return arg;
+		return [consumed, { [Symbol.iterator]() { return iterator; } }];
 	}
 }
 

src/vs/base/common/map.ts

@@ -5,7 +5,6 @@
 
 import { URI } from 'vs/base/common/uri';
 import { CharCode } from 'vs/base/common/charCode';
-import { FIN } from './iterator';
 
 /**
  * @deprecated ES6: use `[...SetOrMap.values()]`
@@ -369,7 +368,7 @@ export class TernarySearchTree<E> {
 				this._forEach(node, value => data.push(value));
 			}
 			if (idx >= data.length) {
-				return FIN;
+				return { done: true, value: undefined };
 			}
 
 			if (!res) {

src/vs/base/common/resourceTree.ts

@@ -5,7 +5,6 @@
 
 import { memoize } from 'vs/base/common/decorators';
 import * as paths from 'vs/base/common/path';
-import { Iterator } from 'vs/base/common/iterator';
 import { relativePath, joinPath } from 'vs/base/common/resources';
 import { URI } from 'vs/base/common/uri';
 import { PathIterator, values } from 'vs/base/common/map';
@@ -15,7 +14,7 @@ export interface IResourceNode<T, C = void> {
 	readonly relativePath: string;
 	readonly name: string;
 	readonly element: T | undefined;
-	readonly children: Iterator<IResourceNode<T, C>>;
+	readonly children: Iterable<IResourceNode<T, C>>;
 	readonly childrenCount: number;
 	readonly parent: IResourceNode<T, C> | undefined;
 	readonly context: C;
@@ -30,8 +29,8 @@ class Node<T, C> implements IResourceNode<T, C> {
 		return this._children.size;
 	}
 
-	get children(): Iterator<Node<T, C>> {
-		return Iterator.fromArray(values(this._children));
+	get children(): Iterable<Node<T, C>> {
+		return [...values(this._children)];
 	}
 
 	@memoize
@@ -69,7 +68,9 @@ function collect<T, C>(node: IResourceNode<T, C>, result: T[]): T[] {
 		result.push(node.element);
 	}
 
-	Iterator.forEach(node.children, child => collect(child, result));
+	for (const child of node.children) {
+		collect(child, result);
+	}
 
 	return result;
 }

src/vs/base/test/browser/ui/tree/compressedObjectTreeModel.test.ts

@@ -5,7 +5,7 @@
 
 import * as assert from 'assert';
 import { compress, ICompressedTreeElement, ICompressedTreeNode, decompress, CompressedObjectTreeModel } from 'vs/base/browser/ui/tree/compressedObjectTreeModel';
-import { Iterator } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { ITreeNode } from 'vs/base/browser/ui/tree/tree';
 import { ISpliceable } from 'vs/base/common/sequence';
 
@@ -16,7 +16,7 @@ interface IResolvedCompressedTreeElement<T> extends ICompressedTreeElement<T> {
 
 function resolve<T>(treeElement: ICompressedTreeElement<T>): IResolvedCompressedTreeElement<T> {
 	const result: any = { element: treeElement.element };
-	const children = Iterator.collect(Iterator.map(Iterator.from(treeElement.children), resolve));
+	const children = [...Iterable.map(Iterable.from(treeElement.children), resolve)];
 
 	if (treeElement.incompressible) {
 		result.incompressible = true;
@@ -315,25 +315,25 @@ suite('CompressedObjectTree', function () {
 			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
 			const model = new CompressedObjectTreeModel<number>('test', toSpliceable(list));
 
-			model.setChildren(null, Iterator.fromArray([
+			model.setChildren(null, [
 				{ element: 0 },
 				{ element: 1 },
 				{ element: 2 }
-			]));
+			]);
 
 			assert.deepEqual(toArray(list), [[0], [1], [2]]);
 			assert.equal(model.size, 3);
 
-			model.setChildren(null, Iterator.fromArray([
+			model.setChildren(null, [
 				{ element: 3 },
 				{ element: 4 },
 				{ element: 5 },
-			]));
+			]);
 
 			assert.deepEqual(toArray(list), [[3], [4], [5]]);
 			assert.equal(model.size, 3);
 
-			model.setChildren(null, Iterator.empty());
+			model.setChildren(null);
 			assert.deepEqual(toArray(list), []);
 			assert.equal(model.size, 0);
 		});
@@ -342,34 +342,34 @@ suite('CompressedObjectTree', function () {
 			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
 			const model = new CompressedObjectTreeModel<number>('test', toSpliceable(list));
 
-			model.setChildren(null, Iterator.fromArray([
+			model.setChildren(null, [
 				{
-					element: 0, children: Iterator.fromArray([
+					element: 0, children: [
 						{ element: 10 },
 						{ element: 11 },
 						{ element: 12 },
-					])
+					]
 				},
 				{ element: 1 },
 				{ element: 2 }
-			]));
+			]);
 
 			assert.deepEqual(toArray(list), [[0], [10], [11], [12], [1], [2]]);
 			assert.equal(model.size, 6);
 
-			model.setChildren(12, Iterator.fromArray([
+			model.setChildren(12, [
 				{ element: 120 },
 				{ element: 121 }
-			]));
+			]);
 
 			assert.deepEqual(toArray(list), [[0], [10], [11], [12], [120], [121], [1], [2]]);
 			assert.equal(model.size, 8);
 
-			model.setChildren(0, Iterator.empty());
+			model.setChildren(0);
 			assert.deepEqual(toArray(list), [[0], [1], [2]]);
 			assert.equal(model.size, 3);
 
-			model.setChildren(null, Iterator.empty());
+			model.setChildren(null);
 			assert.deepEqual(toArray(list), []);
 			assert.equal(model.size, 0);
 		});
@@ -378,50 +378,50 @@ suite('CompressedObjectTree', function () {
 			const list: ITreeNode<ICompressedTreeNode<number>>[] = [];
 			const model = new CompressedObjectTreeModel<number>('test', toSpliceable(list));
 
-			model.setChildren(null, Iterator.fromArray([
+			model.setChildren(null, [
 				{
-					element: 1, children: Iterator.fromArray([{
-						element: 11, children: Iterator.fromArray([{
-							element: 111, children: Iterator.fromArray([
+					element: 1, children: [{
+						element: 11, children: [{
+							element: 111, children: [
 								{ element: 1111 },
 								{ element: 1112 },
 								{ element: 1113 },
-							])
-						}])
-					}])
+							]
+						}]
+					}]
 				}
-			]));
+			]);
 
 			assert.deepEqual(toArray(list), [[1, 11, 111], [1111], [1112], [1113]]);
 			assert.equal(model.size, 6);
 
-			model.setChildren(11, Iterator.fromArray([
+			model.setChildren(11, [
 				{ element: 111 },
 				{ element: 112 },
 				{ element: 113 },
-			]));
+			]);
 
 			assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113]]);
 			assert.equal(model.size, 5);
 
-			model.setChildren(113, Iterator.fromArray([
+			model.setChildren(113, [
 				{ element: 1131 }
-			]));
+			]);
 
 			assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131]]);
 			assert.equal(model.size, 6);
 
-			model.setChildren(1131, Iterator.fromArray([
+			model.setChildren(1131, [
 				{ element: 1132 }
-			]));
+			]);
 
 			assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131, 1132]]);
 			assert.equal(model.size, 7);
 
-			model.setChildren(1131, Iterator.fromArray([
+			model.setChildren(1131, [
 				{ element: 1132 },
 				{ element: 1133 },
-			]));
+			]);
 
 			assert.deepEqual(toArray(list), [[1, 11], [111], [112], [113, 1131], [1132], [1133]]);
 			assert.equal(model.size, 8);

src/vs/base/test/browser/ui/tree/indexTreeModel.test.ts

@@ -6,7 +6,6 @@
 import * as assert from 'assert';
 import { ITreeNode, ITreeFilter, TreeVisibility } from 'vs/base/browser/ui/tree/tree';
 import { ISpliceable } from 'vs/base/common/sequence';
-import { Iterator } from 'vs/base/common/iterator';
 import { IndexTreeModel, IIndexTreeNode } from 'vs/base/browser/ui/tree/indexTreeModel';
 
 function toSpliceable<T>(arr: T[]): ISpliceable<T> {
@@ -34,11 +33,11 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{ element: 0 },
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(list.length, 3);
 		assert.deepEqual(list[0].element, 0);
@@ -56,17 +55,17 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
-				element: 0, children: Iterator.fromArray([
+				element: 0, children: [
 					{ element: 10 },
 					{ element: 11 },
 					{ element: 12 },
-				])
+				]
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(list.length, 6);
 		assert.deepEqual(list[0].element, 0);
@@ -93,17 +92,17 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
-				element: 0, collapsed: true, children: Iterator.fromArray([
+				element: 0, collapsed: true, children: [
 					{ element: 10 },
 					{ element: 11 },
 					{ element: 12 },
-				])
+				]
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(list.length, 3);
 		assert.deepEqual(list[0].element, 0);
@@ -121,11 +120,11 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{ element: 0 },
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(list.length, 3);
 
@@ -146,17 +145,17 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
-				element: 0, children: Iterator.fromArray([
+				element: 0, children: [
 					{ element: 10 },
 					{ element: 11 },
 					{ element: 12 },
-				])
+				]
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(list.length, 6);
 
@@ -180,17 +179,17 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
-				element: 0, children: Iterator.fromArray([
+				element: 0, children: [
 					{ element: 10 },
 					{ element: 11 },
 					{ element: 12 },
-				])
+				]
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(list.length, 6);
 
@@ -208,17 +207,17 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
-				element: 0, collapsed: true, children: Iterator.fromArray([
+				element: 0, collapsed: true, children: [
 					{ element: 10 },
 					{ element: 11 },
 					{ element: 12 },
-				])
+				]
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(list.length, 3);
 
@@ -233,17 +232,17 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
-				element: 0, children: Iterator.fromArray([
+				element: 0, children: [
 					{ element: 10 },
 					{ element: 11 },
 					{ element: 12 },
-				])
+				]
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(list.length, 6);
 
@@ -264,17 +263,17 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
-				element: 0, collapsed: true, children: Iterator.fromArray([
+				element: 0, collapsed: true, children: [
 					{ element: 10 },
 					{ element: 11 },
 					{ element: 12 },
-				])
+				]
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(list.length, 3);
 
@@ -304,7 +303,7 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
 				element: 1, children: [
 					{
@@ -319,7 +318,7 @@ suite('IndexTreeModel', function () {
 					{ element: 21 }
 				]
 			}
-		]));
+		]);
 
 		assert.deepEqual(list.length, 5);
 		assert.deepEqual(toArray(list), [1, 11, 111, 2, 21]);
@@ -337,13 +336,13 @@ suite('IndexTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
-				element: 0, children: Iterator.fromArray([
+				element: 0, children: [
 					{ element: 10 }
-				])
+				]
 			}
-		]));
+		]);
 
 		assert.deepEqual(list.length, 2);
 
@@ -406,7 +405,7 @@ suite('IndexTreeModel', function () {
 
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
 				element: 0, children: [
 					{ element: 1 },
@@ -418,7 +417,7 @@ suite('IndexTreeModel', function () {
 					{ element: 7 }
 				]
 			}
-		]));
+		]);
 
 		assert.deepEqual(list.length, 4);
 		assert.deepEqual(toArray(list), [0, 2, 4, 6]);
@@ -440,14 +439,14 @@ suite('IndexTreeModel', function () {
 
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
 				element: 0, children: [
 					{ element: 1 },
 					{ element: 2 }
 				]
 			}
-		]));
+		]);
 
 		assert.deepEqual(toArray(list), []);
 	});
@@ -463,7 +462,7 @@ suite('IndexTreeModel', function () {
 
 		const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
 				element: 0, children: [
 					{ element: 1 },
@@ -475,7 +474,7 @@ suite('IndexTreeModel', function () {
 					{ element: 7 }
 				]
 			},
-		]));
+		]);
 
 		assert.deepEqual(toArray(list), [0, 1, 2, 3, 4, 5, 6, 7]);
 
@@ -502,7 +501,7 @@ suite('IndexTreeModel', function () {
 
 		const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
 				element: 'vscode', children: [
 					{ element: '.build' },
@@ -522,7 +521,7 @@ suite('IndexTreeModel', function () {
 					}
 				]
 			},
-		]));
+		]);
 
 		assert.deepEqual(list.length, 10);
 
@@ -548,7 +547,7 @@ suite('IndexTreeModel', function () {
 
 		const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
 				element: 'vscode', children: [
 					{ element: '.build' },
@@ -568,7 +567,7 @@ suite('IndexTreeModel', function () {
 					}
 				]
 			},
-		]));
+		]);
 
 		assert.deepEqual(list.length, 10);
 
@@ -594,7 +593,7 @@ suite('IndexTreeModel', function () {
 
 		const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{
 				element: 'vscode', collapsed: true, children: [
 					{ element: '.build' },
@@ -614,7 +613,7 @@ suite('IndexTreeModel', function () {
 					}
 				]
 			},
-		]));
+		]);
 
 		assert.deepEqual(toArray(list), ['vscode']);
 
@@ -642,17 +641,17 @@ suite('IndexTreeModel', function () {
 			const list: IIndexTreeNode<number>[] = [];
 			const model = new IndexTreeModel<number>('test', toSpliceable(list), -1);
 
-			model.splice([0], 0, Iterator.fromArray([
+			model.splice([0], 0, [
 				{
-					element: 0, children: Iterator.fromArray([
+					element: 0, children: [
 						{ element: 10 },
 						{ element: 11 },
 						{ element: 12 },
-					])
+					]
 				},
 				{ element: 1 },
 				{ element: 2 }
-			]));
+			]);
 
 			assert.deepEqual(model.getNodeLocation(list[0]), [0]);
 			assert.deepEqual(model.getNodeLocation(list[1]), [0, 0]);
@@ -672,7 +671,7 @@ suite('IndexTreeModel', function () {
 
 			const model = new IndexTreeModel<number>('test', toSpliceable(list), -1, { filter });
 
-			model.splice([0], 0, Iterator.fromArray([
+			model.splice([0], 0, [
 				{
 					element: 0, children: [
 						{ element: 1 },
@@ -684,7 +683,7 @@ suite('IndexTreeModel', function () {
 						{ element: 7 }
 					]
 				}
-			]));
+			]);
 
 			assert.deepEqual(model.getNodeLocation(list[0]), [0]);
 			assert.deepEqual(model.getNodeLocation(list[1]), [0, 1]);
@@ -704,11 +703,11 @@ suite('IndexTreeModel', function () {
 
 		const model = new IndexTreeModel<string>('test', toSpliceable(list), 'root', { filter });
 
-		model.splice([0], 0, Iterator.fromArray([
+		model.splice([0], 0, [
 			{ element: 'silver' },
 			{ element: 'gold' },
 			{ element: 'platinum' }
-		]));
+		]);
 
 		assert.deepEqual(toArray(list), ['silver', 'gold', 'platinum']);
 
@@ -716,11 +715,11 @@ suite('IndexTreeModel', function () {
 		model.refilter();
 		assert.deepEqual(toArray(list), ['platinum']);
 
-		model.splice([0], Number.POSITIVE_INFINITY, Iterator.fromArray([
+		model.splice([0], Number.POSITIVE_INFINITY, [
 			{ element: 'silver' },
 			{ element: 'gold' },
 			{ element: 'platinum' }
-		]));
+		]);
 		assert.deepEqual(toArray(list), ['platinum']);
 
 		model.refilter();

src/vs/base/test/browser/ui/tree/objectTree.test.ts

@@ -7,7 +7,6 @@ import * as assert from 'assert';
 import { ITreeNode, ITreeRenderer } from 'vs/base/browser/ui/tree/tree';
 import { IListVirtualDelegate, IIdentityProvider } from 'vs/base/browser/ui/list/list';
 import { ObjectTree, CompressibleObjectTree, ICompressibleTreeRenderer } from 'vs/base/browser/ui/tree/objectTree';
-import { Iterator } from 'vs/base/common/iterator';
 import { ICompressedTreeNode } from 'vs/base/browser/ui/tree/compressedObjectTreeModel';
 
 suite('ObjectTree', function () {
@@ -46,17 +45,17 @@ suite('ObjectTree', function () {
 		});
 
 		test('should be able to navigate', () => {
-			tree.setChildren(null, Iterator.fromArray([
+			tree.setChildren(null, [
 				{
-					element: 0, children: Iterator.fromArray([
+					element: 0, children: [
 						{ element: 10 },
 						{ element: 11 },
 						{ element: 12 },
-					])
+					]
 				},
 				{ element: 1 },
 				{ element: 2 }
-			]));
+			]);
 
 			const navigator = tree.navigate();
 
@@ -87,17 +86,17 @@ suite('ObjectTree', function () {
 		});
 
 		test('should skip collapsed nodes', () => {
-			tree.setChildren(null, Iterator.fromArray([
+			tree.setChildren(null, [
 				{
-					element: 0, collapsed: true, children: Iterator.fromArray([
+					element: 0, collapsed: true, children: [
 						{ element: 10 },
 						{ element: 11 },
 						{ element: 12 },
-					])
+					]
 				},
 				{ element: 1 },
 				{ element: 2 }
-			]));
+			]);
 
 			const navigator = tree.navigate();
 
@@ -118,17 +117,17 @@ suite('ObjectTree', function () {
 		test('should skip filtered elements', () => {
 			filter = el => el % 2 === 0;
 
-			tree.setChildren(null, Iterator.fromArray([
+			tree.setChildren(null, [
 				{
-					element: 0, children: Iterator.fromArray([
+					element: 0, children: [
 						{ element: 10 },
 						{ element: 11 },
 						{ element: 12 },
-					])
+					]
 				},
 				{ element: 1 },
 				{ element: 2 }
-			]));
+			]);
 
 			const navigator = tree.navigate();
 
@@ -150,17 +149,17 @@ suite('ObjectTree', function () {
 		});
 
 		test('should be able to start from node', () => {
-			tree.setChildren(null, Iterator.fromArray([
+			tree.setChildren(null, [
 				{
-					element: 0, children: Iterator.fromArray([
+					element: 0, children: [
 						{ element: 10 },
 						{ element: 11 },
 						{ element: 12 },
-					])
+					]
 				},
 				{ element: 1 },
 				{ element: 2 }
-			]));
+			]);
 
 			const navigator = tree.navigate(1);
 
@@ -291,50 +290,50 @@ suite('CompressibleObjectTree', function () {
 		const tree = new CompressibleObjectTree<number>('test', container, new Delegate(), [new Renderer()]);
 		tree.layout(200);
 
-		tree.setChildren(null, Iterator.fromArray([
+		tree.setChildren(null, [
 			{
-				element: 1, children: Iterator.fromArray([{
-					element: 11, children: Iterator.fromArray([{
-						element: 111, children: Iterator.fromArray([
+				element: 1, children: [{
+					element: 11, children: [{
+						element: 111, children: [
 							{ element: 1111 },
 							{ element: 1112 },
 							{ element: 1113 },
-						])
-					}])
-				}])
+						]
+					}]
+				}]
 			}
-		]));
+		]);
 
 		let rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
 		assert.deepEqual(rows, ['1/11/111', '1111', '1112', '1113']);
 
-		tree.setChildren(11, Iterator.fromArray([
+		tree.setChildren(11, [
 			{ element: 111 },
 			{ element: 112 },
 			{ element: 113 },
-		]));
+		]);
 
 		rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
 		assert.deepEqual(rows, ['1/11', '111', '112', '113']);
 
-		tree.setChildren(113, Iterator.fromArray([
+		tree.setChildren(113, [
 			{ element: 1131 }
-		]));
+		]);
 
 		rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
 		assert.deepEqual(rows, ['1/11', '111', '112', '113/1131']);
 
-		tree.setChildren(1131, Iterator.fromArray([
+		tree.setChildren(1131, [
 			{ element: 1132 }
-		]));
+		]);
 
 		rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
 		assert.deepEqual(rows, ['1/11', '111', '112', '113/1131/1132']);
 
-		tree.setChildren(1131, Iterator.fromArray([
+		tree.setChildren(1131, [
 			{ element: 1132 },
 			{ element: 1133 },
-		]));
+		]);
 
 		rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
 		assert.deepEqual(rows, ['1/11', '111', '112', '113/1131', '1132', '1133']);
@@ -348,19 +347,19 @@ suite('CompressibleObjectTree', function () {
 		const tree = new CompressibleObjectTree<number>('test', container, new Delegate(), [new Renderer()]);
 		tree.layout(200);
 
-		tree.setChildren(null, Iterator.fromArray([
+		tree.setChildren(null, [
 			{
-				element: 1, children: Iterator.fromArray([{
-					element: 11, children: Iterator.fromArray([{
-						element: 111, children: Iterator.fromArray([
+				element: 1, children: [{
+					element: 11, children: [{
+						element: 111, children: [
 							{ element: 1111 },
 							{ element: 1112 },
 							{ element: 1113 },
-						])
-					}])
-				}])
+						]
+					}]
+				}]
 			}
-		]));
+		]);
 
 		let rows = toArray(container.querySelectorAll('.monaco-tl-contents')).map(row => row.textContent);
 		assert.deepEqual(rows, ['1/11/111', '1111', '1112', '1113']);

src/vs/base/test/browser/ui/tree/objectTreeModel.test.ts

@@ -7,7 +7,6 @@ import * as assert from 'assert';
 import { ITreeNode } from 'vs/base/browser/ui/tree/tree';
 import { ISpliceable } from 'vs/base/common/sequence';
 import { ObjectTreeModel } from 'vs/base/browser/ui/tree/objectTreeModel';
-import { Iterator } from 'vs/base/common/iterator';
 
 function toSpliceable<T>(arr: T[]): ISpliceable<T> {
 	return {
@@ -35,25 +34,25 @@ suite('ObjectTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new ObjectTreeModel<number>('test', toSpliceable(list));
 
-		model.setChildren(null, Iterator.fromArray([
+		model.setChildren(null, [
 			{ element: 0 },
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(toArray(list), [0, 1, 2]);
 		assert.equal(model.size, 3);
 
-		model.setChildren(null, Iterator.fromArray([
+		model.setChildren(null, [
 			{ element: 3 },
 			{ element: 4 },
 			{ element: 5 },
-		]));
+		]);
 
 		assert.deepEqual(toArray(list), [3, 4, 5]);
 		assert.equal(model.size, 3);
 
-		model.setChildren(null, Iterator.empty());
+		model.setChildren(null);
 		assert.deepEqual(toArray(list), []);
 		assert.equal(model.size, 0);
 	});
@@ -62,34 +61,34 @@ suite('ObjectTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new ObjectTreeModel<number>('test', toSpliceable(list));
 
-		model.setChildren(null, Iterator.fromArray([
+		model.setChildren(null, [
 			{
-				element: 0, children: Iterator.fromArray([
+				element: 0, children: [
 					{ element: 10 },
 					{ element: 11 },
 					{ element: 12 },
-				])
+				]
 			},
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(toArray(list), [0, 10, 11, 12, 1, 2]);
 		assert.equal(model.size, 6);
 
-		model.setChildren(12, Iterator.fromArray([
+		model.setChildren(12, [
 			{ element: 120 },
 			{ element: 121 }
-		]));
+		]);
 
 		assert.deepEqual(toArray(list), [0, 10, 11, 12, 120, 121, 1, 2]);
 		assert.equal(model.size, 8);
 
-		model.setChildren(0, Iterator.empty());
+		model.setChildren(0);
 		assert.deepEqual(toArray(list), [0, 1, 2]);
 		assert.equal(model.size, 3);
 
-		model.setChildren(null, Iterator.empty());
+		model.setChildren(null);
 		assert.deepEqual(toArray(list), []);
 		assert.equal(model.size, 0);
 	});
@@ -98,16 +97,16 @@ suite('ObjectTreeModel', function () {
 		const list: ITreeNode<number>[] = [];
 		const model = new ObjectTreeModel<number>('test', toSpliceable(list));
 
-		model.setChildren(null, Iterator.fromArray([
+		model.setChildren(null, [
 			{ element: 0, collapsed: true }
-		]));
+		]);
 
 		assert.deepEqual(toArray(list), [0]);
 
-		model.setChildren(0, Iterator.fromArray([
+		model.setChildren(0, [
 			{ element: 1 },
 			{ element: 2 }
-		]));
+		]);
 
 		assert.deepEqual(toArray(list), [0]);
 

src/vs/base/test/common/iterator.test.ts

@@ -4,19 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as assert from 'assert';
-import { Iterator, Iterable } from 'vs/base/common/iterator';
-
-suite('Iterator', () => {
-	test('concat', () => {
-		const first = Iterator.fromArray([1, 2, 3]);
-		const second = Iterator.fromArray([4, 5, 6]);
-		const third = Iterator.fromArray([7, 8, 9]);
-		const actualIterator = Iterator.concat(first, second, third);
-		const actual = Iterator.collect(actualIterator);
-
-		assert.deepEqual(actual, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
-	});
-});
+import { Iterable } from 'vs/base/common/iterator';
 
 suite('Iterable', function () {
 

src/vs/workbench/contrib/markers/browser/markersView.ts

@@ -23,7 +23,7 @@ import { IMarkersWorkbenchService } from 'vs/workbench/contrib/markers/browser/m
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import { localize } from 'vs/nls';
 import { IContextKey, IContextKeyService, ContextKeyEqualsExpr, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
-import { Iterator } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { ITreeElement, ITreeNode, ITreeContextMenuEvent, ITreeRenderer } from 'vs/base/browser/ui/tree/tree';
 import { Relay, Event, Emitter } from 'vs/base/common/event';
 import { WorkbenchObjectTree, ResourceNavigator, IListService, IWorkbenchObjectTreeOptions } from 'vs/platform/list/browser/listService';
@@ -50,16 +50,13 @@ import { ViewPane, IViewPaneOptions } from 'vs/workbench/browser/parts/views/vie
 import { IViewDescriptorService } from 'vs/workbench/common/views';
 import { IOpenerService } from 'vs/platform/opener/common/opener';
 
-function createResourceMarkersIterator(resourceMarkers: ResourceMarkers): Iterator<ITreeElement<TreeElement>> {
-	const markersIt = Iterator.fromArray(resourceMarkers.markers);
-
-	return Iterator.map(markersIt, m => {
-		const relatedInformationIt = Iterator.from(m.relatedInformation);
-		const children = Iterator.map(relatedInformationIt, r => ({ element: r }));
+function createResourceMarkersIterator(resourceMarkers: ResourceMarkers): Iterable<ITreeElement<TreeElement>> {
+	return Iterable.map(resourceMarkers.markers, m => {
+		const relatedInformationIt = Iterable.from(m.relatedInformation);
+		const children = Iterable.map(relatedInformationIt, r => ({ element: r }));
 
 		return { element: m, children };
 	});
-
 }
 
 export class MarkersView extends ViewPane implements IMarkerFilterController {
@@ -338,7 +335,7 @@ export class MarkersView extends ViewPane implements IMarkerFilterController {
 		} else {
 			resourceMarkers = this.markersWorkbenchService.markersModel.resourceMarkers;
 		}
-		this.tree.setChildren(null, Iterator.map(Iterator.fromArray(resourceMarkers), m => ({ element: m, children: createResourceMarkersIterator(m) })));
+		this.tree.setChildren(null, Iterable.map(resourceMarkers, m => ({ element: m, children: createResourceMarkersIterator(m) })));
 	}
 
 	private updateFilter() {

src/vs/workbench/contrib/preferences/browser/settingsEditor2.ts

@@ -14,7 +14,7 @@ import { Delayer, ThrottledDelayer, timeout, IntervalTimer } from 'vs/base/commo
 import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
 import * as collections from 'vs/base/common/collections';
 import { getErrorMessage, isPromiseCanceledError } from 'vs/base/common/errors';
-import { Iterator } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { KeyCode } from 'vs/base/common/keyCodes';
 import { Disposable } from 'vs/base/common/lifecycle';
 import * as platform from 'vs/base/common/platform';
@@ -55,10 +55,8 @@ import { SettingsEditor2Input } from 'vs/workbench/services/preferences/common/p
 import { Settings2EditorModel } from 'vs/workbench/services/preferences/common/preferencesModels';
 import { fromNow } from 'vs/base/common/date';
 
-function createGroupIterator(group: SettingsTreeGroupElement): Iterator<ITreeElement<SettingsTreeGroupChild>> {
-	const groupsIt = Iterator.fromArray(group.children);
-
-	return Iterator.map(groupsIt, g => {
+function createGroupIterator(group: SettingsTreeGroupElement): Iterable<ITreeElement<SettingsTreeGroupChild>> {
+	return Iterable.map(group.children, g => {
 		return {
 			element: g,
 			children: g instanceof SettingsTreeGroupElement ?

src/vs/workbench/contrib/preferences/browser/tocTree.ts

@@ -8,7 +8,7 @@ import { IListVirtualDelegate } from 'vs/base/browser/ui/list/list';
 import { DefaultStyleController, IAccessibilityProvider } from 'vs/base/browser/ui/list/listWidget';
 import { IObjectTreeOptions, ObjectTree } from 'vs/base/browser/ui/tree/objectTree';
 import { ITreeElement, ITreeNode, ITreeRenderer } from 'vs/base/browser/ui/tree/tree';
-import { Iterator } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { editorBackground, transparent, foreground } from 'vs/platform/theme/common/colorRegistry';
 import { attachStyler } from 'vs/platform/theme/common/styler';
@@ -138,11 +138,10 @@ class TOCTreeDelegate implements IListVirtualDelegate<SettingsTreeElement> {
 	}
 }
 
-export function createTOCIterator(model: TOCTreeModel | SettingsTreeGroupElement, tree: TOCTree): Iterator<ITreeElement<SettingsTreeGroupElement>> {
+export function createTOCIterator(model: TOCTreeModel | SettingsTreeGroupElement, tree: TOCTree): Iterable<ITreeElement<SettingsTreeGroupElement>> {
 	const groupChildren = <SettingsTreeGroupElement[]>model.children.filter(c => c instanceof SettingsTreeGroupElement);
-	const groupsIt = Iterator.fromArray(groupChildren);
 
-	return Iterator.map(groupsIt, g => {
+	return Iterable.map(groupChildren, g => {
 		const hasGroupChildren = g.children.some(c => c instanceof SettingsTreeGroupElement);
 
 		return {

src/vs/workbench/contrib/scm/browser/repositoryPane.ts

@@ -35,7 +35,7 @@ import { ITreeNode, ITreeFilter, ITreeSorter, ITreeContextMenuEvent } from 'vs/b
 import { ResourceTree, IResourceNode } from 'vs/base/common/resourceTree';
 import { ISequence, ISplice } from 'vs/base/common/sequence';
 import { ICompressibleTreeRenderer, ICompressibleKeyboardNavigationLabelProvider } from 'vs/base/browser/ui/tree/objectTree';
-import { Iterator } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { ICompressedTreeNode, ICompressedTreeElement } from 'vs/base/browser/ui/tree/compressedObjectTreeModel';
 import { URI } from 'vs/base/common/uri';
 import { FileKind } from 'vs/platform/files/common/files';
@@ -397,8 +397,8 @@ interface IGroupItem {
 
 function groupItemAsTreeElement(item: IGroupItem, mode: ViewModelMode): ICompressedTreeElement<TreeElement> {
 	const children = mode === ViewModelMode.List
-		? Iterator.map(Iterator.fromArray(item.resources), element => ({ element, incompressible: true }))
-		: Iterator.map(item.tree.root.children, node => asTreeElement(node, true));
+		? Iterable.map(item.resources, element => ({ element, incompressible: true }))
+		: Iterable.map(item.tree.root.children, node => asTreeElement(node, true));
 
 	return { element: item.group, children, incompressible: true, collapsible: true };
 }
@@ -406,7 +406,7 @@ function groupItemAsTreeElement(item: IGroupItem, mode: ViewModelMode): ICompres
 function asTreeElement(node: IResourceNode<ISCMResource, ISCMResourceGroup>, forceIncompressible: boolean): ICompressedTreeElement<TreeElement> {
 	return {
 		element: (node.childrenCount === 0 && node.element) ? node.element : node,
-		children: Iterator.map(node.children, node => asTreeElement(node, false)),
+		children: Iterable.map(node.children, node => asTreeElement(node, false)),
 		incompressible: !!node.element || forceIncompressible
 	};
 }

src/vs/workbench/contrib/search/browser/searchView.ts

@@ -13,7 +13,7 @@ import { IAction, ActionRunner } from 'vs/base/common/actions';
 import { Delayer } from 'vs/base/common/async';
 import * as errors from 'vs/base/common/errors';
 import { Event } from 'vs/base/common/event';
-import { Iterator } from 'vs/base/common/iterator';
+import { Iterable } from 'vs/base/common/iterator';
 import { KeyCode, KeyMod } from 'vs/base/common/keyCodes';
 import { dispose, IDisposable } from 'vs/base/common/lifecycle';
 import * as env from 'vs/base/common/platform';
@@ -533,7 +533,7 @@ export class SearchView extends ViewPane {
 		}
 	}
 
-	private createResultIterator(collapseResults: ISearchConfigurationProperties['collapseResults']): Iterator<ITreeElement<RenderableMatch>> {
+	private createResultIterator(collapseResults: ISearchConfigurationProperties['collapseResults']): Iterable<ITreeElement<RenderableMatch>> {
 		const folderMatches = this.searchResult.folderMatches()
 			.filter(fm => !fm.isEmpty())
 			.sort(searchMatchComparer);
@@ -542,20 +542,17 @@ export class SearchView extends ViewPane {
 			return this.createFolderIterator(folderMatches[0], collapseResults);
 		}
 
-		const foldersIt = Iterator.fromArray(folderMatches);
-		return Iterator.map(foldersIt, folderMatch => {
+		return Iterable.map(folderMatches, folderMatch => {
 			const children = this.createFolderIterator(folderMatch, collapseResults);
 			return <ITreeElement<RenderableMatch>>{ element: folderMatch, children };
 		});
 	}
 
-	private createFolderIterator(folderMatch: FolderMatch, collapseResults: ISearchConfigurationProperties['collapseResults']): Iterator<ITreeElement<RenderableMatch>> {
+	private createFolderIterator(folderMatch: FolderMatch, collapseResults: ISearchConfigurationProperties['collapseResults']): Iterable<ITreeElement<RenderableMatch>> {
 		const sortOrder = this.searchConfig.sortOrder;
-		const filesIt = Iterator.fromArray(
-			folderMatch.matches()
-				.sort((a, b) => searchMatchComparer(a, b, sortOrder)));
+		const matches = folderMatch.matches().sort((a, b) => searchMatchComparer(a, b, sortOrder));
 
-		return Iterator.map(filesIt, fileMatch => {
+		return Iterable.map(matches, fileMatch => {
 			const children = this.createFileIterator(fileMatch);
 
 			let nodeExists = true;
@@ -568,14 +565,12 @@ export class SearchView extends ViewPane {
 		});
 	}
 
-	private createFileIterator(fileMatch: FileMatch): Iterator<ITreeElement<RenderableMatch>> {
-		const matchesIt = Iterator.from(
-			fileMatch.matches()
-				.sort(searchMatchComparer));
-		return Iterator.map(matchesIt, r => (<ITreeElement<RenderableMatch>>{ element: r }));
+	private createFileIterator(fileMatch: FileMatch): Iterable<ITreeElement<RenderableMatch>> {
+		const matches = fileMatch.matches().sort(searchMatchComparer);
+		return Iterable.map(matches, r => (<ITreeElement<RenderableMatch>>{ element: r }));
 	}
 
-	private createIterator(match: FolderMatch | FileMatch | SearchResult, collapseResults: ISearchConfigurationProperties['collapseResults']): Iterator<ITreeElement<RenderableMatch>> {
+	private createIterator(match: FolderMatch | FileMatch | SearchResult, collapseResults: ISearchConfigurationProperties['collapseResults']): Iterable<ITreeElement<RenderableMatch>> {
 		return match instanceof SearchResult ? this.createResultIterator(collapseResults) :
 			match instanceof FolderMatch ? this.createFolderIterator(match, collapseResults) :
 				this.createFileIterator(match);