debt - let sequence and first use native promises

src/vs/base/common/async.ts

@@ -333,7 +333,7 @@ export function always<T>(winjsPromiseOrThenable: Thenable<T>, callback: () => v
  * promise will complete to an array of results from each promise.
  */
 
-export function sequence<T>(promiseFactories: ITask<Thenable<T>>[]): TPromise<T[]> {
+export function sequence<T>(promiseFactories: ITask<Thenable<T>>[]): Promise<T[]> {
 	const results: T[] = [];
 	let index = 0;
 	const len = promiseFactories.length;
@@ -352,49 +352,27 @@ export function sequence<T>(promiseFactories: ITask<Thenable<T>>[]): TPromise<T[
 			return n.then(thenHandler);
 		}
 
-		return TPromise.as(results);
+		return Promise.resolve(results);
 	}
 
-	return TPromise.as(null).then(thenHandler);
+	return Promise.resolve(null).then(thenHandler);
 }
 
-export function first2<T>(promiseFactories: ITask<Promise<T>>[], shouldStop: (t: T) => boolean = t => !!t, defaultValue: T = null): Promise<T> {
-
+export function first<T>(promiseFactories: ITask<Thenable<T>>[], shouldStop: (t: T) => boolean = t => !!t, defaultValue: T = null): Promise<T> {
 	let index = 0;
 	const len = promiseFactories.length;
 
-	const loop = () => {
+	const loop: () => Promise<T> = () => {
 		if (index >= len) {
 			return Promise.resolve(defaultValue);
 		}
-		const factory = promiseFactories[index++];
-		const promise = factory();
-		return promise.then(result => {
-			if (shouldStop(result)) {
-				return Promise.resolve(result);
-			}
-			return loop();
-		});
-	};
-
-	return loop();
-}
-
-export function first<T>(promiseFactories: ITask<TPromise<T>>[], shouldStop: (t: T) => boolean = t => !!t, defaultValue: T = null): TPromise<T> {
-	let index = 0;
-	const len = promiseFactories.length;
-
-	const loop: () => TPromise<T> = () => {
-		if (index >= len) {
-			return TPromise.as(defaultValue);
-		}
 
 		const factory = promiseFactories[index++];
-		const promise = factory();
+		const promise = Promise.resolve(factory());
 
 		return promise.then(result => {
 			if (shouldStop(result)) {
-				return TPromise.as(result);
+				return Promise.resolve(result);
 			}
 
 			return loop();

src/vs/editor/contrib/format/format.ts

@@ -11,7 +11,7 @@ import { ITextModel } from 'vs/editor/common/model';
 import { registerDefaultLanguageCommand, registerLanguageCommand } from 'vs/editor/browser/editorExtensions';
 import { DocumentFormattingEditProviderRegistry, DocumentRangeFormattingEditProviderRegistry, OnTypeFormattingEditProviderRegistry, FormattingOptions, TextEdit } from 'vs/editor/common/modes';
 import { IModelService } from 'vs/editor/common/services/modelService';
-import { first2 } from 'vs/base/common/async';
+import { first } from 'vs/base/common/async';
 import { Position } from 'vs/editor/common/core/position';
 import { CancellationToken } from 'vs/base/common/cancellation';
 
@@ -34,7 +34,7 @@ export function getDocumentRangeFormattingEdits(model: ITextModel, range: Range,
 		return Promise.reject(new NoProviderError());
 	}
 
-	return first2(providers.map(provider => () => {
+	return first(providers.map(provider => () => {
 		return Promise.resolve(provider.provideDocumentRangeFormattingEdits(model, range, options, token))
 			.then(undefined, onUnexpectedExternalError);
 	}), result => !isFalsyOrEmpty(result));
@@ -48,7 +48,7 @@ export function getDocumentFormattingEdits(model: ITextModel, options: Formattin
 		return getDocumentRangeFormattingEdits(model, model.getFullModelRange(), options, token);
 	}
 
-	return first2(providers.map(provider => () => {
+	return first(providers.map(provider => () => {
 		return Promise.resolve(provider.provideDocumentFormattingEdits(model, options, token))
 			.then(undefined, onUnexpectedExternalError);
 	}), result => !isFalsyOrEmpty(result));

src/vs/editor/contrib/parameterHints/provideSignatureHelp.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { first2 } from 'vs/base/common/async';
+import { first } from 'vs/base/common/async';
 import { onUnexpectedExternalError } from 'vs/base/common/errors';
 import { registerDefaultLanguageCommand } from 'vs/editor/browser/editorExtensions';
 import { Position } from 'vs/editor/common/core/position';
@@ -21,7 +21,7 @@ export function provideSignatureHelp(model: ITextModel, position: Position, cont
 
 	const supports = modes.SignatureHelpProviderRegistry.ordered(model);
 
-	return first2(supports.map(support => () => {
+	return first(supports.map(support => () => {
 		return Promise.resolve(support.provideSignatureHelp(model, position, token, context)).catch(onUnexpectedExternalError);
 	}));
 }

src/vs/editor/contrib/suggest/suggest.ts

@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { first2 } from 'vs/base/common/async';
+import { first } from 'vs/base/common/async';
 import { isFalsyOrEmpty } from 'vs/base/common/arrays';
 import { compareIgnoreCase } from 'vs/base/common/strings';
 import { assign } from 'vs/base/common/objects';
@@ -111,7 +111,7 @@ export function provideSuggestionItems(
 		}));
 	});
 
-	const result = first2(factory, () => {
+	const result = first(factory, () => {
 		// stop on result or cancellation
 		return hasResult || token.isCancellationRequested;
 	}).then(() => {

src/vs/editor/contrib/wordHighlighter/wordHighlighter.ts

@@ -5,7 +5,7 @@
 
 import * as nls from 'vs/nls';
 
-import { first2, createCancelablePromise, CancelablePromise, timeout } from 'vs/base/common/async';
+import { first, createCancelablePromise, CancelablePromise, timeout } from 'vs/base/common/async';
 import { onUnexpectedExternalError, onUnexpectedError } from 'vs/base/common/errors';
 import { Range } from 'vs/editor/common/core/range';
 import * as editorCommon from 'vs/editor/common/editorCommon';
@@ -45,7 +45,7 @@ export function getOccurrencesAtPosition(model: ITextModel, position: Position,
 	// in order of score ask the occurrences provider
 	// until someone response with a good result
 	// (good = none empty array)
-	return first2(orderedByScore.map(provider => () => {
+	return first(orderedByScore.map(provider => () => {
 		return Promise.resolve(provider.provideDocumentHighlights(model, position, token))
 			.then(undefined, onUnexpectedExternalError);
 	}), result => !isFalsyOrEmpty(result));

src/vs/workbench/services/textmodelResolver/test/textModelResolverService.test.ts

@@ -72,16 +72,19 @@ suite('Workbench - TextModelResolverService', () => {
 		let resource = URI.from({ scheme: 'test', authority: null, path: 'thePath' });
 		let input: ResourceEditorInput = instantiationService.createInstance(ResourceEditorInput, 'The Name', 'The Description', resource);
 
-		return input.resolve().then(model => {
+		return input.resolve().then(async model => {
 			assert.ok(model);
 			assert.equal(snapshotToString((model as ResourceEditorModel).createSnapshot()), 'Hello Test');
 
 			let disposed = false;
-			once(model.onDispose)(() => {
-				disposed = true;
+			let disposedPromise = new Promise(resolve => {
+				once(model.onDispose)(() => {
+					disposed = true;
+					resolve();
+				});
 			});
-
 			input.dispose();
+			await disposedPromise;
 			assert.equal(disposed, true);
 
 			dispose.dispose();
@@ -161,7 +164,10 @@ suite('Workbench - TextModelResolverService', () => {
 		modelRef1.dispose();
 		assert(!textModel.isDisposed(), 'the text model should still not be disposed');
 
+		let p1 = new Promise(resolve => textModel.onWillDispose(resolve));
 		modelRef2.dispose();
+
+		await p1;
 		assert(textModel.isDisposed(), 'the text model should finally be disposed');
 
 		disposable.dispose();