allow workspace edit in all will-events, #43768

Author: jrieken

src/vs/vscode.proposed.d.ts

@@ -831,6 +831,7 @@ declare module 'vscode' {
 	export interface FileWillCreateEvent {
 		readonly creating: ReadonlyArray<Uri>;
 		waitUntil(thenable: Thenable<any>): void;
+		waitUntil(thenable: Thenable<WorkspaceEdit>): void;
 	}
 
 	export interface FileDeleteEvent {
@@ -840,6 +841,7 @@ declare module 'vscode' {
 	export interface FileWillDeleteEvent {
 		readonly deleting: ReadonlyArray<Uri>;
 		waitUntil(thenable: Thenable<any>): void;
+		waitUntil(thenable: Thenable<WorkspaceEdit>): void;
 	}
 
 	export interface FileRenameEvent {
@@ -848,7 +850,8 @@ declare module 'vscode' {
 
 	export interface FileWillRenameEvent {
 		readonly renaming: ReadonlyArray<{ oldUri: Uri, newUri: Uri }>;
-		waitUntil(thenable: Thenable<WorkspaceEdit>): void; // TODO@joh support sync/async
+		waitUntil(thenable: Thenable<any>): void;
+		waitUntil(thenable: Thenable<WorkspaceEdit>): void;
 	}
 
 	export namespace workspace {

src/vs/workbench/api/common/extHostFileSystemEventService.ts

@@ -3,17 +3,17 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { flatten } from 'vs/base/common/arrays';
 import { AsyncEmitter, Emitter, Event, IWaitUntil } from 'vs/base/common/event';
 import { IRelativePattern, parse } from 'vs/base/common/glob';
 import { URI, UriComponents } from 'vs/base/common/uri';
 import { ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
 import * as vscode from 'vscode';
-import { ExtHostFileSystemEventServiceShape, FileSystemEvents, IMainContext, MainContext, IResourceFileEditDto, IResourceTextEditDto, MainThreadTextEditorsShape } from './extHost.protocol';
+import { ExtHostFileSystemEventServiceShape, FileSystemEvents, IMainContext, MainContext, MainThreadTextEditorsShape, IResourceFileEditDto, IResourceTextEditDto } from './extHost.protocol';
 import * as typeConverter from './extHostTypeConverters';
 import { Disposable, WorkspaceEdit } from './extHostTypes';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { FileOperation } from 'vs/platform/files/common/files';
+import { flatten } from 'vs/base/common/arrays';
 
 class FileSystemWatcher implements vscode.FileSystemWatcher {
 
@@ -179,38 +179,40 @@ export class ExtHostFileSystemEventService implements ExtHostFileSystemEventServ
 	async $onWillRunFileOperation(operation: FileOperation, target: UriComponents, source: UriComponents | undefined): Promise<any> {
 		switch (operation) {
 			case FileOperation.MOVE:
-				await this._fireWillRename(URI.revive(source!), URI.revive(target));
+				await this._fireWillEvent(this._onWillRenameFile, { renaming: [{ oldUri: URI.revive(source!), newUri: URI.revive(target) }], });
 				break;
 			case FileOperation.DELETE:
-				this._onWillDeleteFile.fireAsync(thenables => (<vscode.FileWillDeleteEvent>{ deleting: [URI.revive(target)], waitUntil: p => thenables.push(Promise.resolve(p)) }));
+				await this._fireWillEvent(this._onWillDeleteFile, { deleting: [URI.revive(target)] });
 				break;
 			case FileOperation.CREATE:
-				this._onWillCreateFile.fireAsync(thenables => (<vscode.FileWillCreateEvent>{ creating: [URI.revive(target)], waitUntil: p => thenables.push(Promise.resolve(p)) }));
+				await this._fireWillEvent(this._onWillCreateFile, { creating: [URI.revive(target)] });
 				break;
 			default:
 			//ignore, dont send
 		}
 	}
 
-	private async _fireWillRename(oldUri: URI, newUri: URI): Promise<any> {
+	private async _fireWillEvent<E extends IWaitUntil>(emitter: AsyncEmitter<E>, data: Omit<E, 'waitUntil'>): Promise<any> {
 
 		const edits: WorkspaceEdit[] = [];
-		await Promise.resolve(this._onWillRenameFile.fireAsync(bucket => {
-			return {
-				renaming: [{ oldUri, newUri }],
-				waitUntil: (thenable: Promise<vscode.WorkspaceEdit>): void => {
-					if (Object.isFrozen(bucket)) {
-						throw new TypeError('waitUntil cannot be called async');
-					}
-					const index = bucket.length;
-					const wrappedThenable = Promise.resolve(thenable).then(result => {
-						// ignore all results except for WorkspaceEdits. Those
-						// are stored in a spare array
-						if (result instanceof WorkspaceEdit) {
-							edits[index] = result;
+		await Promise.resolve(emitter.fireAsync(bucket => {
+			return <E>{
+				...data,
+				...{
+					waitUntil: (thenable: Promise<vscode.WorkspaceEdit>): void => {
+						if (Object.isFrozen(bucket)) {
+							throw new TypeError('waitUntil cannot be called async');
 						}
-					});
-					bucket.push(wrappedThenable);
+						const index = bucket.length;
+						const wrappedThenable = Promise.resolve(thenable).then(result => {
+							// ignore all results except for WorkspaceEdits. Those
+							// are stored in a spare array
+							if (result instanceof WorkspaceEdit) {
+								edits[index] = result;
+							}
+						});
+						bucket.push(wrappedThenable);
+					}
 				}
 			};
 		}));
@@ -230,6 +232,4 @@ export class ExtHostFileSystemEventService implements ExtHostFileSystemEventServ
 		}
 		return this._mainThreadTextEditors.$tryApplyWorkspaceEdit({ edits: flatten(allEdits) });
 	}
-
-
 }