fix integration tests

src/vs/base/common/async.ts

@@ -368,15 +368,15 @@ export function always<T>(promise: TPromise<T>, f: Function): TPromise<T> {
  * Runs the provided list of promise factories in sequential order. The returned
  * promise will complete to an array of results from each promise.
  */
-export function sequence<T>(promiseFactory: ITask<TPromise<T>>[]): TPromise<T[]> {
+export function sequence<T>(promiseFactories: ITask<TPromise<T>>[]): TPromise<T[]> {
 	const results: T[] = [];
 
 	// reverse since we start with last element using pop()
-	promiseFactory = promiseFactory.reverse();
+	promiseFactories = promiseFactories.reverse();
 
 	function next(): Promise {
-		if (promiseFactory.length) {
-			return promiseFactory.pop()();
+		if (promiseFactories.length) {
+			return promiseFactories.pop()();
 		}
 
 		return null;
@@ -398,6 +398,29 @@ export function sequence<T>(promiseFactory: ITask<TPromise<T>>[]): TPromise<T[]>
 	return TPromise.as(null).then(thenHandler);
 }
 
+export function first<T>(promiseFactories: ITask<TPromise<T>>[], shouldStop: (t: T) => boolean = t => !!t): TPromise<T> {
+	promiseFactories = [...promiseFactories.reverse()];
+
+	const loop = () => {
+		if (promiseFactories.length === 0) {
+			return TPromise.as(null);
+		}
+
+		const factory = promiseFactories.pop();
+		const promise = factory();
+
+		return promise.then(result => {
+			if (shouldStop(result)) {
+				return TPromise.as(result);
+			}
+
+			return loop();
+		});
+	};
+
+	return loop();
+}
+
 export function once<T extends Function>(fn: T): T {
 	const _this = this;
 	let didCall = false;

src/vs/editor/common/services/bulkEdit.ts

@@ -76,6 +76,7 @@ class EditTask implements IDisposable {
 	constructor(model: IModel, modelReference: IDisposable) {
 		this._endCursorSelection = null;
 		this._model = model;
+		this._modelReference = modelReference;
 		this._edits = [];
 	}
 
@@ -142,7 +143,11 @@ class EditTask implements IDisposable {
 	}
 
 	dispose() {
-		this._modelReference.dispose();
+		if (this._model) {
+			this._modelReference.dispose();
+			this._modelReference = null;
+			this._model = null;
+		}
 	}
 }
 

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

@@ -6,6 +6,7 @@
 
 import { TPromise } from 'vs/base/common/winjs.base';
 import URI from 'vs/base/common/uri';
+import { first } from 'vs/base/common/async';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IModel } from 'vs/editor/common/editorCommon';
 import { IDisposable, toDisposable, IReference, ReferenceCollection, ImmortalReference } from 'vs/base/common/lifecycle';
@@ -83,14 +84,16 @@ class ResourceModelCollection extends ReferenceCollection<URI, TPromise<ITextEdi
 			return TPromise.as(model);
 		}
 
-		// TODO@Joao just take the first one for now
-		const provider = (this.providers[resource.scheme] || [])[0];
+		const providers = this.providers[resource.scheme] || [];
+		const factories = providers.map(p => () => p.provideTextContent(resource));
 
-		if (!provider) {
-			return TPromise.wrapError(`No model with uri '${resource}' nor a resolver for the scheme '${resource.scheme}'.`);
-		}
+		return first(factories).then(uri => {
+			if (!uri) {
+				return TPromise.wrapError(`Could not resolve any model with uri '${resource}'.`);
+			}
 
-		return provider.provideTextContent(resource);
+			return uri;
+		});
 	}
 }