Merge from vscode 5b9869eb02fa4c96205a74d05cad9164dfd06d60 (#5607)

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

@@ -31,7 +31,7 @@ class ResourceModelCollection extends ReferenceCollection<Promise<ITextEditorMod
 		super();
 	}
 
-	createReferencedObject(key: string, skipActivateProvider?: boolean): Promise<ITextEditorModel> {
+	async createReferencedObject(key: string, skipActivateProvider?: boolean): Promise<ITextEditorModel> {
 		this.modelsToDispose.delete(key);
 
 		const resource = URI.parse(key);
@@ -43,15 +43,19 @@ class ResourceModelCollection extends ReferenceCollection<Promise<ITextEditorMod
 
 		// Virtual documents
 		if (this.providers[resource.scheme]) {
-			return this.resolveTextModelContent(key).then(() => this.instantiationService.createInstance(ResourceEditorModel, resource));
+			await this.resolveTextModelContent(key);
+
+			return this.instantiationService.createInstance(ResourceEditorModel, resource);
 		}
 
 		// Either unknown schema, or not yet registered, try to activate
 		if (!skipActivateProvider) {
-			return this.fileService.activateProvider(resource.scheme).then(() => this.createReferencedObject(key, true));
+			await this.fileService.activateProvider(resource.scheme);
+
+			return this.createReferencedObject(key, true);
 		}
 
-		return Promise.reject(new Error('resource is not available'));
+		throw new Error('resource is not available');
 	}
 
 	destroyReferencedObject(key: string, modelPromise: Promise<ITextEditorModel>): void {
@@ -101,18 +105,17 @@ class ResourceModelCollection extends ReferenceCollection<Promise<ITextEditorMod
 		return this.providers[scheme] !== undefined;
 	}
 
-	private resolveTextModelContent(key: string): Promise<ITextModel> {
+	private async resolveTextModelContent(key: string): Promise<ITextModel> {
 		const resource = URI.parse(key);
 		const providers = this.providers[resource.scheme] || [];
 		const factories = providers.map(p => () => Promise.resolve(p.provideTextContent(resource)));
 
-		return first(factories).then(model => {
-			if (!model) {
-				return Promise.reject(new Error('resource is not available'));
-			}
+		const model = await first(factories);
+		if (!model) {
+			throw new Error('resource is not available');
+		}
 
-			return model;
-		});
+		return model;
 	}
 }
 
@@ -131,14 +134,16 @@ export class TextModelResolverService implements ITextModelService {
 	}
 
 	createModelReference(resource: URI): Promise<IReference<IResolvedTextEditorModel>> {
-		return this._createModelReference(resource);
+		return this.doCreateModelReference(resource);
 	}
 
-	private _createModelReference(resource: URI): Promise<IReference<IResolvedTextEditorModel>> {
+	private async doCreateModelReference(resource: URI): Promise<IReference<IResolvedTextEditorModel>> {
 
 		// Untitled Schema: go through cached input
 		if (resource.scheme === network.Schemas.untitled) {
-			return this.untitledEditorService.loadOrCreate({ resource }).then(model => new ImmortalReference(model as IResolvedTextEditorModel));
+			const model = await this.untitledEditorService.loadOrCreate({ resource });
+
+			return new ImmortalReference(model as IResolvedTextEditorModel);
 		}
 
 		// InMemory Schema: go through model service cache
@@ -154,14 +159,15 @@ export class TextModelResolverService implements ITextModelService {
 
 		const ref = this.resourceModelCollection.acquire(resource.toString());
 
-		return ref.object.then(
-			model => ({ object: model, dispose: () => ref.dispose() }),
-			err => {
-				ref.dispose();
+		try {
+			const model = await ref.object;
 
-				return Promise.reject(err);
-			}
-		);
+			return { object: model as IResolvedTextEditorModel, dispose: () => ref.dispose() };
+		} catch (error) {
+			ref.dispose();
+
+			throw error;
+		}
 	}
 
 	registerTextModelContentProvider(scheme: string, provider: ITextModelContentProvider): IDisposable {