add event for create and delete operations

src/vs/vscode.proposed.d.ts

@@ -708,6 +708,25 @@ declare module 'vscode' {
 	//#endregion
 
 	//#region mjbvz,joh: https://github.com/Microsoft/vscode/issues/43768
+
+	export interface FileCreateEvent {
+		readonly uri: Uri;
+	}
+
+	export interface FileWillCreateEvent {
+		readonly uri: Uri;
+		waitUntil(thenable: Thenable<any>): void;
+	}
+
+	export interface FileDeleteEvent {
+		readonly uri: Uri;
+	}
+
+	export interface FileWillDeleteEvent {
+		readonly uri: Uri;
+		waitUntil(thenable: Thenable<any>): void;
+	}
+
 	export interface FileRenameEvent {
 		readonly oldUri: Uri;
 		readonly newUri: Uri;
@@ -720,8 +739,16 @@ declare module 'vscode' {
 	}
 
 	export namespace workspace {
-		export const onWillRenameFile: Event<FileWillRenameEvent>;
-		export const onDidRenameFile: Event<FileRenameEvent>;
+
+		export const onDidExecuteCreateFile: Event<FileCreateEvent>;
+		export const onWillExecuteCreateFile: Event<FileWillCreateEvent>;
+
+		export const onDidExecuteDeleteFile: Event<FileDeleteEvent>;
+		export const onWillExecuteDeleteFile: Event<FileWillDeleteEvent>;
+
+		export const onWillExecuteRenameFile: Event<FileWillRenameEvent>;
+		export const onDidExecuteRenameFile: Event<FileRenameEvent>;
+
 	}
 	//#endregion
 

src/vs/workbench/api/common/extHost.api.impl.ts

@@ -695,11 +695,27 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 				checkProposedApiEnabled(extension);
 				return extHostLabelService.$registerResourceLabelFormatter(formatter);
 			},
-			onDidRenameFile: (listener: (e: vscode.FileRenameEvent) => any, thisArg?: any, disposables?: vscode.Disposable[]) => {
+			onDidExecuteCreateFile: (listener, thisArg, disposables) => {
+				checkProposedApiEnabled(extension);
+				return extHostFileSystemEvent.onDidCreateFile(listener, thisArg, disposables);
+			},
+			onDidExecuteDeleteFile: (listener, thisArg, disposables) => {
+				checkProposedApiEnabled(extension);
+				return extHostFileSystemEvent.onDidDeleteFile(listener, thisArg, disposables);
+			},
+			onDidExecuteRenameFile: (listener, thisArg, disposables) => {
 				checkProposedApiEnabled(extension);
 				return extHostFileSystemEvent.onDidRenameFile(listener, thisArg, disposables);
 			},
-			onWillRenameFile: (listener: (e: vscode.FileWillRenameEvent) => any, thisArg?: any, disposables?: vscode.Disposable[]) => {
+			onWillExecuteCreateFile: (listener: (e: vscode.FileWillCreateEvent) => any, thisArg?: any, disposables?: vscode.Disposable[]) => {
+				checkProposedApiEnabled(extension);
+				return extHostFileSystemEvent.getOnWillCreateFileEvent(extension)(listener, thisArg, disposables);
+			},
+			onWillExecuteDeleteFile: (listener: (e: vscode.FileWillDeleteEvent) => any, thisArg?: any, disposables?: vscode.Disposable[]) => {
+				checkProposedApiEnabled(extension);
+				return extHostFileSystemEvent.getOnWillDeleteFileEvent(extension)(listener, thisArg, disposables);
+			},
+			onWillExecuteRenameFile: (listener: (e: vscode.FileWillRenameEvent) => any, thisArg?: any, disposables?: vscode.Disposable[]) => {
 				checkProposedApiEnabled(extension);
 				return extHostFileSystemEvent.getOnWillRenameFileEvent(extension)(listener, thisArg, disposables);
 			}

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { flatten } from 'vs/base/common/arrays';
-import { AsyncEmitter, Emitter, Event } from 'vs/base/common/event';
+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';
@@ -97,17 +97,25 @@ class FileSystemWatcher implements vscode.FileSystemWatcher {
 	}
 }
 
-interface WillRenameListener {
+interface IExtensionListener<E> {
 	extension: IExtensionDescription;
-	(e: vscode.FileWillRenameEvent): any;
+	(e: E): any;
 }
 
 export class ExtHostFileSystemEventService implements ExtHostFileSystemEventServiceShape {
 
+	private readonly _onFileSystemEvent = new Emitter<FileSystemEvents>();
 
-	private readonly _onFileEvent = new Emitter<FileSystemEvents>();
 	private readonly _onDidRenameFile = new Emitter<vscode.FileRenameEvent>();
+	private readonly _onDidCreateFile = new Emitter<vscode.FileCreateEvent>();
+	private readonly _onDidDeleteFile = new Emitter<vscode.FileDeleteEvent>();
 	private readonly _onWillRenameFile = new AsyncEmitter<vscode.FileWillRenameEvent>();
+	private readonly _onWillCreateFile = new AsyncEmitter<vscode.FileWillCreateEvent>();
+	private readonly _onWillDeleteFile = new AsyncEmitter<vscode.FileWillDeleteEvent>();
+
+	readonly onDidRenameFile: Event<vscode.FileRenameEvent> = this._onDidRenameFile.event;
+	readonly onDidCreateFile: Event<vscode.FileCreateEvent> = this._onDidCreateFile.event;
+	readonly onDidDeleteFile: Event<vscode.FileDeleteEvent> = this._onDidDeleteFile.event;
 
 
 	constructor(
@@ -121,11 +129,11 @@ export class ExtHostFileSystemEventService implements ExtHostFileSystemEventServ
 	//--- file events
 
 	createFileSystemWatcher(globPattern: string | IRelativePattern, ignoreCreateEvents?: boolean, ignoreChangeEvents?: boolean, ignoreDeleteEvents?: boolean): vscode.FileSystemWatcher {
-		return new FileSystemWatcher(this._onFileEvent.event, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents);
+		return new FileSystemWatcher(this._onFileSystemEvent.event, globPattern, ignoreCreateEvents, ignoreChangeEvents, ignoreDeleteEvents);
 	}
 
 	$onFileEvent(events: FileSystemEvents) {
-		this._onFileEvent.fire(events);
+		this._onFileSystemEvent.fire(events);
 	}
 
 
@@ -136,19 +144,35 @@ export class ExtHostFileSystemEventService implements ExtHostFileSystemEventServ
 			case FileOperation.MOVE:
 				this._onDidRenameFile.fire(Object.freeze({ oldUri: URI.revive(target), newUri: URI.revive(source!) }));
 				break;
-			//todo@joh there are more operations...
+			case FileOperation.DELETE:
+				this._onDidDeleteFile.fire(Object.freeze({ uri: URI.revive(target) }));
+				break;
+			case FileOperation.CREATE:
+				this._onDidCreateFile.fire(Object.freeze({ uri: URI.revive(target) }));
+				break;
+			default:
+			//ignore, dont send
 		}
 	}
 
-	readonly onDidRenameFile: Event<vscode.FileRenameEvent> = this._onDidRenameFile.event;
 
 	getOnWillRenameFileEvent(extension: IExtensionDescription): Event<vscode.FileWillRenameEvent> {
+		return this._createWillExecuteEvent(extension, this._onWillRenameFile);
+	}
+
+	getOnWillCreateFileEvent(extension: IExtensionDescription): Event<vscode.FileWillCreateEvent> {
+		return this._createWillExecuteEvent(extension, this._onWillCreateFile);
+	}
+
+	getOnWillDeleteFileEvent(extension: IExtensionDescription): Event<vscode.FileWillDeleteEvent> {
+		return this._createWillExecuteEvent(extension, this._onWillDeleteFile);
+	}
+
+	private _createWillExecuteEvent<E extends IWaitUntil>(extension: IExtensionDescription, emitter: AsyncEmitter<E>): Event<E> {
 		return (listener, thisArg, disposables) => {
-			const wrappedListener: WillRenameListener = <any>((e: vscode.FileWillRenameEvent) => {
-				listener.call(thisArg, e);
-			});
+			const wrappedListener: IExtensionListener<E> = function wrapped(e: E) { listener.call(thisArg, e); };
 			wrappedListener.extension = extension;
-			return this._onWillRenameFile.event(wrappedListener, undefined, disposables);
+			return emitter.event(wrappedListener, undefined, disposables);
 		};
 	}
 
@@ -157,7 +181,14 @@ export class ExtHostFileSystemEventService implements ExtHostFileSystemEventServ
 			case FileOperation.MOVE:
 				await this._fireWillRename(URI.revive(target), URI.revive(source!));
 				break;
-			//todo@joh there are more operations...
+			case FileOperation.DELETE:
+				this._onWillDeleteFile.fireAsync(thenables => (<vscode.FileWillDeleteEvent>{ uri: URI.revive(target), waitUntil: p => thenables.push(Promise.resolve(p)) }));
+				break;
+			case FileOperation.CREATE:
+				this._onWillCreateFile.fireAsync(thenables => (<vscode.FileWillCreateEvent>{ uri: URI.revive(target), waitUntil: p => thenables.push(Promise.resolve(p)) }));
+				break;
+			default:
+			//ignore, dont send
 		}
 	}
 
@@ -199,6 +230,7 @@ export class ExtHostFileSystemEventService implements ExtHostFileSystemEventServ
 			}
 		}
 		return this._mainThreadTextEditors.$tryApplyWorkspaceEdit({ edits: flatten(allEdits) });
-
 	}
+
+
 }